Move the invocation of Matplotlib's Agg backend right after matplotlib's import. Even if it violates PEP8, it avoids some nasty warnings when runing pcigale-plots.

As the code is much faster now, let's update the number of computed models a bit less often as printing something on screen causes a context switch

We need to sort the sed.info before saving the data. The reason is that the dictionary orders the keys with a hash so it appears random. In addition the order also changes from one process to another (I suspect the hash also depends on a seed). Thanks to Yannick for pointing out this issue.

If there is the redshift information then there is necessarily the luminosity distance too. No need to test separately for the presence of each.

Normalise the SFH appropriately in the same if then else statement. Bonus is that is saves an array multiplication if a specific scaling factor is not given.

When computing the galaxy mass, convert from yr to Myr outside of the integral. That way we only multiply a scalar by 1e6 rather than a large array. Good for speed and memory bandwidth.

Simplify the construction of modules by remove the out_parameter_list dictionary. It was not used anywhere, was not always provided, and was not even up to date.

Switch back to ordered dictionaries for the input parameters after all. That way the list of parameters is kept into a logical order when building the configuration file. The impact on performance is negligible.

InfoDict was made to overcome the slowness to copy an OrderedDict. However since we have removed OrderedDict now, we can just switch to a regular dictionary, which happens to be fast to copy.

JSON is slow. Now that OrderedDict have been removed we can just use marshal to conver modules names and parameters into keys.

We rely on OrderedDict to keep the order of the parameters. However given the way the code is structured currently, there is really no reason for this. So let's just switch to the standard dictionary. This has two advantages. First the standard dictionary is much faster than OrderedDict (implemented in C rather than in pure python). Then, standard dictionaries are marshalable, which makes them usable as keys for other dictionaries.

Simplify a bit the code by removing the normalisation option from the convolve procedure as it duplicates the functionality from the SFH modules.

Do not rely on the index to find the last observation analysed as they may be out of order. Rather use the number of observations already analysed. It should void a spurious carriage return that occurs in some cases.

As python evaluates expressions from the left to the right, put the vector in the rightmost position so that we do not multiply it with a scalar several times.

When computing the flux in filters, np.trapz() become the bottleneck of the code. A large part of the time is spent on safeguards and on operations for nD arrays. However in our specific case we only have 1D arrays. Also we can cache some computed variables, for instance dx which only depends on the wavelength sampling. We do that employing the same key that is used for caching the best sampling of each filter in compute_fnu(). That way the caches are consistent. The key is based on the size of the wavelength grid, the name of the filter, and the redshift.

Replace the SED.info OrderedDict() with a very light weight and speficically tailored reimplementation of an OrderedDict(). The reason is that an OrderedDict() takes an inordinate amount to time to copy. In the end this could amount to a very significant fraction of the total runtime. Do not use this new implementation anywhere or it will break your code. It makes very strong assumptions on how it is to be used.

To verify whether a variable is among the keys of a dictionary there is actually no need to call the keys() function. A dictionary has a __contains__() member which is called when the “in” keyword is used.

There is no need to build a list of keys to check whether a variable is among the keys of a dictionary.

Avoid retrieving the module parameters for the sed.info dictionary each time we process a SED as these parameters are set in stone. Rather add them as class members in the init. This should result in a slight speedup.

Repair the badly broken dustatt_powerlaw module. It did not handle the contribution names properly, which broke the code if the nebular module was called.

Remove leftover comments from debugging and add the stellar population back in the output parameters.

BURGARELLA Denis authored Jul 31, 2015 and Yannick Roehlly committed Jul 31, 2015

For now, CIGALE does not work with a parameterless module, so we use
a fake one.

BURGARELLA Denis authored Jul 31, 2015 and Yannick Roehlly committed Jul 31, 2015

- mbb: modified black body
- param: parameterless module to compute some parameters and add them to
  the information dictionary
- sfhcomb_constant and sfhcomb_delayed: two star formation histories

The pseudo filters used to compute (pseudo) line fluxes must not be
normalised to 1. Also, we set their effective wavelength to the mean
wavelength of the positive part.

The wavelengths must be in angstrom.

Addition of pseudo filters used to compute de fluxes in some lines.
They are composed of a positive part (normalised to 1) above the line
and two negative part (of the same total area) on each side used to
remove the continuum.

The PSEUDO_D4000 pseudo filter measures the difference (not the ratio)
of the 4000 Å break.