Add pseudo filters to measure Halpha, Hbeta, and OIII. Beware that the fluxes will be affected by any underlying absorption line. Also make sure that the continuum part of the filter is not significantly affected by emission lines. It is recommended to adapt the filter depending on the actual resolution of the spectral observations.

Add the sfhdelayedbq module implementing a delayed SFH with a burst/quench. It is described in detail in Ciesla et al. (2017).

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

Add the possibility of computing emission lines through special filters when underlying absorption lines are not subtracted.

Have the nebular module compute and store the intrinsic line luminosities. That way they can be fitted as any flux.

Store the name of the individual lines in the database in order so they can easily be identified and retrieved.

Clarify a bit the description of the redshifting module as we do not always just fit a single galaxy

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.

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.