.. _performance-approximations: Performance Approximations ========================== The engine implements a few approximations to speed up the classical calculations: the point source gridding, the ``pointsource_distance`` approximation, the choice of the ``ps_grid_spacing``, the ``collapse_precision`` approximation, plus the variant sources optimization, which does not change the results. This page describes them, shows how to measure their effect and gives a worked example. .. _point-source-gridding: The point source gridding approximation --------------------------------------- WARNING: *the point source gridding approximation is used only in classical calculations, not in event based calculations!* Most hazard calculations are dominated by distributed seismicity, i.e. area sources and multipoint sources that for the engine are just regular point sources. In such situations the parameter governing the performance is the grid spacing: a calculation with a grid spacing of 50 km produces 25 times less ruptures and it is expected to be 25 times faster than a calculation with a grid spacing of 10 km. The *point source gridding approximation* is a smart way of raising the grid spacing without losing too much precision and without losing too much performance. The idea is two use two kinds of point sources: the original ones and a set of “effective” ones (instances of the class ``CollapsedPointSource``) that essentially are the original sources averaged on a larger grid, determined by the parameter ``ps_grid_spacing``. The plot below should give the idea, the points being the original sources and the squares with ~25 sources each being associated to the collapsed sources: .. figure:: _images/gridding.png For distant sites it is possible to use the large grid (i.e. the CollapsePointSources) without losing much precision, while for close points the original sources must be used. The engine uses the parameter ``pointsource_distance`` to determine when to use the original sources and when to use the collapsed sources. If the ``maximum_distance`` has a value of 500 km and the ``pointsource_distance`` a value of 50 km, then (50/500)^2 = 1% of the sites will be close and 99% of the sites will be far. Therefore you will able to use the collapsed sources for 99% percent of the sites and a huge speedup is to big expected (in reality things are a bit more complicated, since the engine also consider the fact that ruptures have a finite size, but you get the idea). ******************************************* Application: making the Canada model faster ******************************************* In order to give a concrete example, I ran the 2026 Canada model on 7 cities by using the following ``site_model.csv`` file: +----------------+------+-----+------+----------+----------+ | custom_site_id | lon | lat | vs30 | z1pt0 | z2pt5 | +================+======+=====+======+==========+==========+ | montre | -73 | 45 | 368 | 393.6006 | 1.391181 | +----------------+------+-----+------+----------+----------+ | calgar | -114 | 51 | 451 |290.6857 | 1.102391 | +----------------+------+-----+------+----------+----------+ | ottawa | -75 | 45 | 246 | 492.3983 | 2.205382 | +----------------+------+-----+------+----------+----------+ | edmont | -113 | 53 | 372 | 389.0669 | 1.374081 | +----------------+------+-----+------+----------+----------+ | toront | -79 | 43 | 291 | 465.5151 | 1.819785 | +----------------+------+-----+------+----------+----------+ | winnip | -97 | 50 | 229 | 499.7842 | 2.393656 | +----------------+------+-----+------+----------+----------+ | vancou | -123 | 49 | 600 | 125.8340 | 0.795259 | +----------------+------+-----+------+----------+----------+ Notice that we are using a ``custom_site_id`` field to identify the cities. All the calculations below use the current engine (3.27) on a 16-core machine. The exact calculation, with ``ps_grid_spacing=0`` and ``pointsource_distance=1000``, is the reference. It is dominated by the operation "total classical_bysrc", which takes 1115 seconds. With the default ``pointsource_distance = 100``, the time of "total classical_bysrc" goes down to 590 seconds. Enters the point source gridding: by setting ``ps_grid_spacing = 50`` and ``pointsource_distance = 75`` it goes down to 270 seconds, and with ``pointsource_distance = 0`` to 150 seconds. The following table collects the results: +-----------------------+-----------+----------------------------+---------+ | operation | calc_time | approx | speedup | +=======================+===========+============================+=========+ | total classical_bysrc | 1115 | no approx | 1x | +-----------------------+-----------+----------------------------+---------+ | total classical_bysrc | 590 | pointsource_distance = 100 | 1.9x | +-----------------------+-----------+----------------------------+---------+ | total classical_bysrc | 270 | ps_grid_spacing + psd=75 | 4.1x | +-----------------------+-----------+----------------------------+---------+ | total classical_bysrc | 150 | ps_grid_spacing + psd=0 | 7.4x | +-----------------------+-----------+----------------------------+---------+ As you see, by playing with the parameters ``ps_grid_spacing`` and ``pointsource_distance`` it is possible to improve the performance quite a lot. The cost to pay is in the precision of the results. With the engine defaults (``ps_grid_spacing=0`` and ``pointsource_distance = 100``) the hazard maps are quite precise:: $ oq compare hmaps PGA There are no differences within the tolerances atol=0.001, rtol=0%, sids=[0 1 2 3 4 5 6] With the gridding and ``pointsource_distance = 75`` the hazard maps are still quite precise:: $ oq compare hmaps PGA There are no differences within the tolerances atol=0.001, rtol=0%, sids=[0 1 2 3 4 5 6] With the gridding and ``pointsource_distance = 0`` the differences are larger: the root-mean-square difference of the hazard maps is 0.0029 g at poe 0.002105 and 0.0080 g at poe 0.000404, with maximum differences of 0.0049 g and 0.0123 g, well above the tolerance:: $ oq compare hmaps PGA poe | rms-diff | max-diff 0.002105 | 0.0029 | 0.0049 0.000404 | 0.0080 | 0.0123 It should be noticed that if you have 130,000 sites it is likely that there will be a few sites where the point source gridding approximation gives results quite different for the exact results. The commands ``oq compare`` allows you to figure out which are the problematic sites, where they are and how big is the difference from the exact results. You should take into account that even the “exact” results have uncertainties due to all kind of reasons, so even a large difference can be quite acceptable. In particular if the hazard is very low you can ignore any difference since it will have no impact on the risk. Points with low hazard are expected to have large differences, this is why by default *oq compare* use an absolute tolerance of 0.001g, but you can raise that to 0.01g or more. You can also give a relative tolerance of 10% or more. Internally ``oq compare`` calls the function ``numpy.allclose`` see https://numpy.org/doc/stable/reference/generated/numpy.allclose.html for a description of how the tolerances work. By increasing the ``pointsource_distance`` parameter and decreasing the ``ps_grid_spacing`` parameter one can make the approximation as precise as wanted, at the expense of a larger runtime. NB: the speedup depends on the number of sites. In particular, for the full model with hundreds of thousands of sites, the speedup can be even larger. ************************************************************************ How to determine the right value for the ``ps_grid_spacing`` parameter ************************************************************************ The recommended way is to set ``ps_grid_spacing = auto`` and to run the calculation with the ``--calibrate`` option, for instance:: $ oq run job.ini -p ps_grid_spacing=auto --calibrate With this setting the engine determines both ``ps_grid_spacing`` and ``pointsource_distance`` (unless the ``pointsource_distance`` is set in the job.ini) by comparing the hazard of the point sources on a sample of sites with the hazard of the exact calculation, and then stops. The chosen values are logged, and they are stored in the datastore. The calibration works as follows (in engine v3.27, it may change in the future): - the sample has at most 300 sites, it uses a single GMPE per tectonic region type, the two intensity measure types closest to 0.2 s and 1 s and one intensity level every two; - the point sources of each group are sampled: a random third of them is used in the calibration, with a fixed seed, so that the results are reproducible; if the sample of a group is empty, its first point source is used; - the reference is the calculation without gridding and with a ``pointsource_distance`` of 100 km (1000 km would be exact, but too expensive for large maximum distances); - the candidates are the grid spacings 50, 25 and 15 km, each one with the ``pointsource_distance`` values 15, 25, 50 and 75 km (if the ``pointsource_distance`` is set in the job.ini, only that value is tried); - the errors are normalized by ``0.002 + 0.01 * |reference|``, as in ``numpy.testing.assert_allclose`` with ``atol=0.002`` and ``rtol=0.01``, and a candidate is acceptable if the 99th percentile of the normalized error on the hazard maps is at most 1, i.e. the hazard maps are close within these tolerances; - the acceptable candidate with the smallest weight is chosen, where the weight is the estimated cost of the calculation on the sampled point sources, which ranks the candidates like the cost of the full calculation; if no candidate is acceptable, the candidates with a normalized error within 10% of the smallest one are considered, and the cheapest of them is chosen. For the Canada model of the mosaic (CND, 482,898 sites) on current master, the calibration log is the following. The whole preclassical phase, which includes the calibration, takes about one minute on 16 cores:: psgs psd weight mean_err p99_err p99_norm 50 15 7573185 0.0012 0.0135 3.6039 50 25 8300487 0.0009 0.0096 2.5132 50 50 10561253 0.0005 0.0049 1.2019 50 75 13350315 0.0003 0.0032 0.9436 Using ps_grid_spacing=50.0, pointsource_distance=75.0 The errors are absolute, in g, while p99_norm is the normalized error used to choose the candidate. The grid spacings are tried from the largest to the smallest, and the search stops at the first one with a candidate within the tolerance, so the 25 and 15 km grids are not tried here: the 50 km candidates with a pointsource_distance of 15, 25 and 50 km have p99_norm above 1, the one with 75 km has p99_norm of 0.94, and it is chosen. Once the values are known, run the full calculation with them, for instance ``oq run job.ini -p ps_grid_spacing=50 pointsource_distance=75``. The precision can be checked with ``oq compare hcurves`` and ``oq compare uhs``, and the performance with ``oq show performance``. Since version 3.27 the number of contexts generated by the calculation is stored in the ``nctxs`` dataset of the datastore, with the following fields, which are useful to understand how much the approximations reduce the work: - ``exact``: the estimated number of contexts with a ``pointsource_distance`` of 1000 km, taken as exact; - ``psd100``: the estimated number of contexts without gridding, with a ``pointsource_distance`` of 100 km (the ``pointsource_distance`` of the configuration, see ``openquake.cfg``, not the one calibrated by ``auto``); when the calculation is not gridded, it is the estimate with the ``pointsource_distance`` of the calculation instead, which is the reduction logged by the engine; - ``gridded``: the number of contexts of the gridded point sources before ``collapse_precision``; - ``collapsed``: the number of contexts after ``collapse_precision``, shown only if ``collapse_precision`` is nonzero; - ``separate``: the number of contexts without the variant sources optimization (see :ref:`variant-sources`), i.e. if the variants of the sources were computed separately; it is equal to ``collapsed`` when the optimization is not used. If ``ps_grid_spacing`` or ``collapse_precision`` is set, the ``exact`` field is the number of contexts before ``collapse_precision``, counted for all the source types, when no estimate was computed. The ``exact``, ``psd100`` and ``gridded`` fields are zero when they have not been computed. The fields can be displayed with ``oq show context_reduction ``, which also displays the reduction factor of the variant sources optimization. For the ``job_vs30.ini`` file of the ``performance.zip`` archive, run with ``ps_grid_spacing=25``, ``pointsource_distance=15`` and ``collapse_precision=.03`` (engine version 3.27), the ``nctxs`` dataset contains:: exact psd100 gridded collapsed separate 993298176 297900530 48062426 44932370 44932370 Here ``psd100`` is computed with a ``pointsource_distance`` of 100 km, and the gridding reduces the contexts by a factor of 993298176 / 48062426 = 20.67, the value logged as "estimated reduction factor". The collapse_precision reduces them further, from 48062426 to 44932370, a factor of 1.07, so that the total reduction logged as "estimated reduction factor" is 22.11 (gridding 20.67 x collapse 1.07). For the same file run with ``ps_grid_spacing=auto`` and no ``collapse_precision`` (current master), the calibration chooses ``ps_grid_spacing=50`` and ``pointsource_distance=15``, and the ``nctxs`` dataset contains:: exact psd100 gridded collapsed separate 993298176 297900530 43815054 43815054 43815054 Since ``collapse_precision`` is zero, ``collapsed`` is equal to ``gridded``. The gridding reduces the contexts by a factor of 993298176 / 43815054 = 22.67, which is the value logged as:: cfactor = 43_815_054, estimated reduction factor 22.67 (gridding) With ``collapse_precision=0.03`` added (same ``ps_grid_spacing=auto`` run, same calibration), the ``nctxs`` dataset contains:: exact psd100 gridded collapsed separate 993298176 297900530 43815054 27488651 27488651 The collapse reduces the contexts from 43815054 to 27488651, a factor of 43815054 / 27488651 = 1.59, so that the total reduction is 993298176 / 27488651 = 36.13, logged as:: cfactor = 27_488_651, estimated reduction factor 36.13 (gridding 22.67 x collapse 1.59) If you want to explore other values, you can run a sensitivity analysis. The command ``oq sensitivity_analysis`` prints a bash script which creates one calculation for each combination of the parameters, given in TOML syntax:: $ oq sensitivity_analysis job.ini 'ps_grid_spacing = [0, 25, 50]' > sa.sh $ bash sa.sh The script runs the calculations one after the other, and at the end it collects them with ``oq collect_jobs``. The calculation with ``ps_grid_spacing=0`` is the reference, but notice that it still uses the ``pointsource_distance`` approximation, with the default of 100 km, so it is not the exact calculation unless the ``pointsource_distance`` is set to 1000 km as well. To speed up the sensitivity analysis on large models, set the environment variable ``OQ_SAMPLE_SITES=.01``, which uses 100 times less sites (``oq show performance`` shows the timings of the calculations). Note that the calibration, the weights and the precision of the ``ps_grid_spacing`` approximation change at every release, so only the results at a fixed release are meaningful and you should not expect the same numbers and performance across releases even if the model and the parameters are the same. ********************************************************************** The collapse_precision approximation ********************************************************************** In version 3.27 we introduce an additional approximation which is able to collapse ruptures coming from generic poissonian sources (i.e. not point sources). The ``collapse_precision`` parameter merges the contexts of the same site which differ only by a small change of distance. Two contexts are merged when they have the same site, the same rupture parameters and distances equal within the given relative precision: the distances are grouped by rounding ``sign(d) * log(1 + |d|)`` divided by ``collapse_precision``; the sign is kept because some distances, such as ``rx`` and ``ry0``, are signed (they are positive on one side of the rupture and negative on the other), while ``rrup`` is always positive. The merged context has the sum of the occurrence rates and the average distance, weighted by the rates. The dip, strike, rake and width are compared after rounding to one decimal place, while the other rupture parameters must be equal. The GSIMs are grouped by the rupture parameters and the distances they require. The contexts are collapsed once per group, using only the parameters required by that group, and the probabilities of each group are computed with the GSIMs of the group. Therefore the GSIMs requiring fewer parameters collapse more, at the cost of collapsing the contexts once per group. For instance, in a logic tree where one GSIM requires the ``hypo_depth`` parameter in addition to the magnitude and the rake, the contexts are collapsed twice: once with all the parameters for the GSIM which needs ``hypo_depth``, and once without ``hypo_depth`` for the other GSIMs. The approximation is used only by the ``classical`` calculator, for the Poissonian sources: the nonparametric sources and the non-Poissonian temporal occurrence models are never collapsed. The default is ``collapse_precision = 0``, meaning no collapsing, and a typical value is ``0.02`` or ``0.03``:: collapse_precision = 0.03 Collapsing is useful only if many ruptures of a source are at similar distances from the same site, which is the case for the far away sites and for the sources with few rupture parameters. It is not useful when the ruptures have many different parameters: for instance, along a long fault two ruptures with the same magnitude are at different positions, so their parameters almost never match, and GMPEs with many distance terms (such as the ones with rupture distance and hanging-wall effects) make the contexts of different ruptures differ. In these cases the collapse removes few contexts and it can even make the calculation slower, because of the extra work. The effect of the collapse is logged in the ``cfactor`` line, which reports the reduction factor with the collapse part as in:: cfactor = 9_732, reduction factor 2.14 (psdist 1.63 x collapse 1.32) If the contexts removed by the collapse are less than 10% of the contexts, the engine warns that ``collapse_precision`` should be turned off. Always check the runtime, since the collapse has a cost of its own. For instance, on the ``performance.zip`` archive with ``ps_grid_spacing=30`` and engine version 3.27, the collapse removes about 16% of the contexts (from 50,182,457 to 42,110,255, a reduction factor of 1.19). The precision of the ``ps_grid_spacing`` approximation depends on the engine release, and it has improved substantially in engine 3.27 compared with the past. As an example, consider the Lisbon site of the EUR model (``ps_grid_spacing=50`` and ``pointsource_distance=50``) compared with the reference without gridding (``ps_grid_spacing=0`` and ``pointsource_distance=1000``, i.e. the exact calculation). For the mean PGA hazard curve, the maximum relative difference from the reference, for probabilities of at least 1e-4, is 7.7% with engine 3.26 and 0.7% with engine 3.27, so the error has been reduced by an order of magnitude. The reduction is smaller at long periods: for SA(2.0) it goes from 2.7% to 1.5%. With engine 3.27 we have *much* better precision without losing performance, so much that in the hazard curves or UHS plots it is impossible to see the difference visually. Of course for very small intensities numeric errors are much larger because the rates are very sensitive to the maximum distance and to many details, however below 0.01 g there is no reason to be precise since the hazard is too small to have a practical effect. Measuring the reduction of the contexts --------------------------------------- The ``classical`` calculator logs, at the end of the classical phase, the number of contexts it computes (``cfactor``) and the reduction factor with respect to the exact calculation, i.e. with ``ps_grid_spacing=0`` and a ``pointsource_distance`` of 1000 km. The reduction factor is the product of two parts, which are both logged: - the reduction due to the point-source gridding (``gridding``) or to the ``pointsource_distance`` approximation (``psdist``), and - the reduction due to ``collapse_precision`` (``collapse``). For instance, a line like:: cfactor = 56_527_540, estimated reduction factor 17.52 (gridding 17.52 x collapse 1.00) means that the gridded calculation computes about 17.5 times fewer contexts than the exact one. The factors marked as ``estimated`` are computed from a fast estimate of the number of contexts, which is accurate to a few percent (the estimated and the actual number of contexts of the exact calculation differ by 1.6% in the example below). The runtime is not directly proportional to the number of contexts, so it is useful to measure it as well: the classical time is the one reported in the logs by the line ``Received ... from classical``. The following table shows the results of the ``performance.zip`` calculation, which can be downloaded from https://downloads.openquake.org/jobs/performance.zip. The calculations were run with an AMD Ryzen 9 9955HX 16-Core Processor: .. list-table:: :header-rows: 1 * - pointsource_distance - ps_grid_spacing - collapse_precision - classical time (s) - cfactor (contexts) - reduction factor * - 1000 - 0 - none - 1011 - 1,006,014,489 - 1.00 * - 100 - 0 - none - 326 - 300,941,271 - 3.34 (psdist) * - 25 - 25 - none - 58 - 56,527,540 - 17.52 (gridding, estimated) * - 25 - 25 - 0.03 - 64 - 50,848,933 - 19.48 (gridding, estimated) Note that the efficiency of the collapse of the ruptures and of the ``pointsource_distance`` approximation depends very much on the version of the engine: the numbers above are valid for the engine version 3.27 and they will change in other versions, as well as they will depend on the hardware. They are meant to show how to read the logs, not as a benchmark. .. _variant-sources: Variant sources optimization ---------------------------- When the source model logic tree contains uncertainties on the sources, every source has several *variants*, one for each combination of the branches applied to it. If the uncertainties only change the magnitude-frequency distribution of the source, and not its geometry, the variants have the same ruptures with different occurrence rates, so the contexts (and the distances) can be computed only once and shared by all the variants: the number of contexts can be reduced by up to the number of variants, and the calculation can become much faster. Since version 3.27 the engine applies this optimization automatically to the variants of a source satisfying the following conditions: - the sources are Poissonian, i.e. not mutually exclusive, not in a cluster and with a Poisson temporal occurrence model; - the uncertainties are geometry-preserving, i.e. ``abGRAbsolute``, ``abMaxMagAbsolute``, ``bGRAbsolute``, ``bGRRelative``, ``bACAbsolute``, ``bACRelative``, ``maxMagGRAbsolute``, ``minMagGRAbsolute``, ``maxMagGRRelative``, ``maxMagGRRelativeNoMoBalance``, ``maxMagAndDeltaMagACRelative``, ``maxMagAndDeltaMagACRelativeNoMoBalance``, ``incrementalMFDAbsolute``, ``multiMFDAbsolute``, ``truncatedGRFromSlipAbsolute``, ``recurSet``, ``recurRow`` or ``rateSplit``; the geometry-changing uncertainties (for instance ``setLowerSeismDepthAbsolute``) split the variants in groups with the same geometry, and the optimization is applied within each group; - the magnitudes of each variant are contained in the magnitudes of the variant with the most magnitudes (the *base*), as it happens for instance for the ``maxMagGRAbsolute`` variants of a truncated Gutenberg-Richter distribution; the variants with other magnitudes are grouped separately. The contexts are computed for the base variant and the probabilities of exceedance are computed once for each magnitude. Since the rates are linear in the occurrence rates of Poissonian ruptures, the contributions ``occurrence_rate * poe`` of the ruptures of each source are summed once, and every variant gets the sum multiplied by the ratio between its occurrence rate and the occurrence rate of the base at that magnitude (zero for the magnitudes missing in the variant, for instance the ones above its maximum magnitude). Unlike the approximations in this page, the optimization does not change the results, apart from floating-point rounding. At the end of the classical phase the engine logs the reduction of the contexts due to the optimization, i.e. the ratio between the contexts that the variants would generate if computed separately and the contexts actually computed, which are stored in the ``separate`` and ``collapsed`` fields of the ``nctxs`` dataset; they can be displayed with ``oq show context_reduction ``. Notice that the optimization applies only to the variants generated by the logic tree: if the same source appears in several source model files with different magnitude-frequency distributions, each copy is computed separately and the engine logs a warning suggesting to keep a single copy and to move the distributions in the logic tree, for instance with an ``incrementalMFDAbsolute`` uncertainty. As an example, consider the ``LogicTreeCase2ClassicalPSHA`` demo (see :ref:`Case2 demo `), where the sources ``first`` and ``second`` have 9 variants each, given by 3 ``abGRAbsolute`` and 3 ``maxMagGRAbsolute`` branches. The following comparison runs the demo with ``OQ_DISTRIBUTE=no`` on the same machine with engine 3.26.2, where every variant is computed separately, and with the master branch (version 3.27), where the uncertainties are applied in the workers (see :ref:`classical-internals`) and the optimization is used. The timings are from a single run of each version:: engine 3.26.2 master ClassicalCalculator.run (s) 5.69 0.90 number of contexts 22,422 2,935 number of ruptures 35,916 4,461 calls to get_distances (classical phase) 14,496 1,620 total wall-clock time (s) 39.3 3.3 The difference is visible in the ``source_info`` dataset: engine 3.26.2 stores 18 entries, i.e. 9 copies of each source with a semicolon suffix (``first;0``, ..., ``first;8``), one for each combination of the ``abGRAbsolute`` and ``maxMagGRAbsolute`` branches applied to the source, while master stores 2 entries, one for each source, since the uncertainties are applied in the workers. The hazard curves and the hazard maps of the two runs are the same within the tolerance of ``oq compare`` (``atol=0.001``, ``rtol=0%``). The classical phase is 6.3 times faster and the number of contexts is reduced by a factor of 7.6 (the contexts were counted directly in both engines, and the counts match the logged ``cfactor``); in master the reduction is logged as:: The variant sources optimization reduced the contexts from 22_422 to 2_935, a factor 7.64 and ``oq show context_reduction`` displays:: | field | contexts | |-----------------+----------| | exact | 0 | | psd100 | 0 | | gridded | 0 | | collapsed | 2_935 | | separate | 22_422 | | variants factor | 7.64 | The reduction factor is explained as follows: - engine 3.26.2 computes the contexts of all the 9 copies of each source; - master computes the 9 variants of a source together (see ``make_results``): both ``abGRAbsolute`` and ``maxMagGRAbsolute`` keep the geometry, so the contexts are computed only once, for the variant with the most magnitudes, and the occurrence rates are rescaled for each variant, with a zero rate for the magnitudes above the maximum magnitude of the variant. The reduction is less than 9 because of ``maxMagGRAbsolute``: in engine 3.26.2 the copies with a smaller maximum magnitude have fewer contexts, since the ruptures above their maximum magnitude are cut out, while master computes the contexts of the largest maximum magnitude. For the area source ``first`` (maximum magnitude 7.0, 7.3 or 7.6) the copies have 1,672, 2,064 and 2,530 contexts, each repeated 3 times, i.e. 18,798 contexts against 2,530 in master, a factor of 7.4. For the fault source ``second`` (maximum magnitude 7.5, 7.8 or 8.0) the ruptures above magnitude 7.5 cover the whole fault, so there are few of them and the cut is small: 3,624 contexts against 405, a factor of 8.9. The distances are computed only for the fault source ``second``, since the point sources use a faster path. The demo has a single site and ``get_distances`` is called 4 times per rupture, so the calls in the classical phase are reduced by the same factor of 8.9 as the contexts of ``second``. Engine 3.26.2 makes 1,716 more calls in the preclassical phase, to estimate the weight of the sources.