Avoid making a copy when storing the redshifted SED. This SED will never be modified. This is done by copying what is returned by get_sed rather than having get_sed return directly a copy.

Do display the model counter twice when the numbers of models is a multiple of the printing frequency.

Setters and getters for the flux, extprop, and intprop dictionaries are too expensive, in particular as they do not provide any real safety in the present case.

With the previous commit a relatively large fraction of the time is spent integrating the attenuated spectrum. Let's use a faster way to compute the integral

It turns out that elevating 10 to some power is very slow. Because the attenuation curve will not change between two calls, we save its shape for the young and old ages rather than recomputing it every single time. This leads to a massive speedup.

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.

Now that upper limits are stored as positive values, we do not need to take the opposite when correcting the χ².

Make the cache faster by avoiding a serialisation with marshel. Rather let's use tuples of of the values of the parameters. This works because they are stored in ordered dictionaries.

Import factorial from scipy.special rather than scipy.misc as importing from the latter is deprecated since Scipy 1.0.0.

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

No need to take for the present of upper limits when computing the scaling for regular fluxes as upper limits are now stored separately.

When computing the scaling factor, correct the extensive properties for the difference between the distance of the model and the actual distance of the object.

Internally store the error on the upper limits as positive values now that we split them away from regular values.

Store the upper limits and the regular fluxes/properties in separate dictionaries so that we do not have to test when fitting whether they are upper limits of not.

Start the parallel processes with fork rather than spawn on Linux platforms, resulting in a faster startup.

Scalar assignments to a RawArray is a very fast operation. Using a getting represents an important overhead. Eliminate it by accessing directly the private attribuate.

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

Expand the SharedArray class so that from the point of view of the rest of the code it behaves like a Numpy array. This is a very minimal implementation that works with the operations we do on RawArrays. Internally we use a RawArray or a Numpy array representation depending on whether the operation done is scalar or vector.

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.