Maximise the CPU cache hit rate with computing the χ² by storing contiguously all the models at a given redshift.

Improve the presentation of the sanity check and only do as at the end of the run so that sporadic messages are not displayed in individual blocks.

Ensure that best models are properly computed when models are computed by blocks and that no fit could be made in one or more blocks.

As we modify the sed object, make a deep copy so we do not accidentally alter the model in the cache. These models should probably be made read-only, if it is not too costly in terms of performance.

Move the negative sign to the constant to avoid having to take the negative of an entire array. Also use a multiplication rather than a division (even though a division by 2 is a special case).

Correct the scaling of the best-fit to account to the difference between the grid and the observed redshifts/distances.

Take into account the effect of the differential redshifting between the observed and grid redshifts.

Make sure that the best fit can be computed when the redshift is estimated rather than given as an input.

Completely change the SED cache. Now we rely on the fact that for a given set of modules we only need to store only one model in cache. If there is a cache miss, it means we can discard this one model. In turn the cache key simply becomes the number of modules used, making it easier and faster to access. To check whether the stored module corresponds to the requested one, we store both the model parameters and the SED in a tuple.

The counter can become a bottleneck when many parallel processes are running concurrently because of the lock to update it. To address this we implement a Counter class that only updates the counter periodically rather than at each iteration. The number of models actually computed at any moment is kept in a local counter.

Make sure that the valid models are selected for the scaling array too so it is the same size as the likelihood array.

Do not access SharedArray.array directly anymore but rather use the fact that SharedArray behaves somewhat like a Numpy array for basical operations.

Store the model fluxes and properties in dictionaries of SharedArray rather than large SharedArray and adapt the rest of the code. It may be slightly slower doing so but it makes memory allocation easier and it allows to retrieve the values of the fluxes/properties much more convenient as we do not have to retain the index.

Rather than fitting again the best model to retrieve the proper scaling, let's keep it. It takes little memory.

Store the Bayesian estimates in dictionaries of SharedArray rather than in one large SharedArray. This has the advantage to allocate smaller arrays, which is generally easier. Using dictionaries also makes it easier to access the values of a given property. First patch in a series to use dictionaries more extensively.

Get automatically the index of the module redshifting for the parameter_list dictionary when getting the real redshift for computing the best model SED.