Python SED Fitter documentation¶

This package is an experimental Python port of the SED Fitting tool described in Robitaille et al. (2007) and is still under active development.

Important

No guarantees are made about the accuracy of the results, and users are responsible for ensuring that the results are reasonable and that they understand all the limitations inherent to SED fitting.

Please report any issues with the package here (not by email).

User documentation¶

Introduction¶

The concept of the SED fitter is very simple: consider a set of sources to be studied. For each source, the SED fitter can fit models, such as model stellar photospheres, YSO model SEDs, as well as galaxy and AGB templates, to the multi-wavelength photometry measurements of this particular source using linear regression.

The scale factor $S$ (which is related to the luminosity and distance of the sources) and the extinction $A_{\rm V}$ are used as free parameters in the fitting process. The result for any given source is a value for the goodness of fit and best-fit values $S$ and $A_{\rm V}$ for every single model. These fits can then be analyzed to derive properties of the source.

To quantify the goodness/badness of each fit to each source, we calculate the $\chi^2$ value:

$\chi^2=\sum_{i=1}^N \left(\frac{\langle\,\log_{10}{[F_{\nu}(\lambda_i)]}\,\rangle-\log_{10}{[M_{\nu}(\lambda_i)]}}{\sigma(\langle\,\log_{10}{[F_{\nu}](\lambda_i)}\,\rangle)}\right)^2$

where $\langle\,\log_{10}{[F_{\nu}(\lambda_i)]}\,\rangle$ are the mean fluxes in log space, flux values at a given wavelength $\lambda_{i}$ , $\sigma(\langle\,\log_{10}{[F_{\nu}](\lambda_i)}\,\rangle)$ are the flux uncertainties in log space, and $\log_{10}{[M_{\nu}(\lambda_i)]}$ are the extincted and scaled model log fluxes. For more details, see Robitaille et al (2007). In this manual we sometimes refer to the $\chi^2$ per datapoint, $\chi^2/n_{\rm data}$ , where the number of datapoints does not include upper and lower limits.

The SED fitter uses the concept of model packages, which are single directories containing SEDs, convolved fluxes, parameters, and a description of the models, all in a common format. There are two kinds of models that can be used with the SED fitter:

Models for which the absolute distance cannot be determined from the fit (e.g. unscaled stellar photosphere models). This is usually used for the purpose of filtering out a certain class of sources, for example foreground/background stars.
Models that are absolutely scaled in flux, to a distance of 1kpc. In this case, it is also possible to specify fluxes as a function of aperture - in this case, the fitting procedure is more complex as it involves computing the aperture-dependent SEDs for a fine grid of distances, and optionally removing models that would clearly be extended relative to the aperture chosen. This is described in more detail in Robitaille et al (2007).

Installation¶

Requirements¶

The SED fitter requires Python 2.6, 2.7, 3.2, or 3.3, and the following Python packages to be installed:

Numpy
Scipy
Matplotlib
Astropy 0.3 or later

First-time Python users may want to consider an all-in-one Python installation package, such as the Anaconda Python Distribution which provides all of the above dependencies.

Installation¶

You can install the SED fitting package using:

pip install sedfitter

or you can get the latest tar file from PyPI.

If you want to install the latest developer version, you will need to clone the git repository:

git clone http://github.com/astrofrog/sedfitter

You can then install the package with:

cd sedfitter
python setup.py install

Testing¶

If you want to check that all the tests are running correctly with your Python configuration, you can also run:

python setup.py test

in the source directory. If there are no errors, you are good to go!

Fitting SEDs to sources¶

Typical workflow¶

Once the data has been prepared following the description in Data format, and that you have a set of models in the format described in Creating model packages the typical workflow to follow when using the SED fitting tool is:

Fit a given set of models to the data
Optionally split the output between well- and badly-fit sources
Make plots of the SED fits, or of the parameter distribution

Each of these steps can be performed by one ore more functions in the SED Fitting tool, which are described below in detail:

Note on quantities and units¶

The Python SED fitting tool makes use of the astropy.units package to handle units and unit conversions. Several of the options that need to be specified in the functions described below require Quantity instances. Defining quantities is straightforward:

from astropy import units as u

# Define scalar quantity
q1 = 3. * u.kpc

# Define array quantity using a list
q2 = [1., 2., 3.] * u.arcsec

# Define array quantity using a Numpy array
q3 = np.array([1., 2., 3.]) * u.cm ** 2 / u.g

Fitting the models to the data¶

In order to fit the data, you will need to make use of the fit() function, which can be imported using:

from sedfitter import fit

At a minimum, you will need to call the function with the following input:

The file containing the data (see Data format).
The list of filters and aperture radii for which the data is given (see Common filter names).
The directory containing the models (see Available Model Packages and Creating model packages).
The name of the output file
The range of Av and distances to assume for the fits
An extinction law, given as a opacities to extinction (in cm^2/g or equivalent) versus wavelength.

The fit() page describes in detail how each of these inputs should be specified, and also lists additional options to further fine-tune the fitting and the output.

The following is a complete example showing how to use the fit() function:

from astropy import units as u
from sedfitter import fit
from sedfitter.extinction import Extinction

# Define path to models
model_dir = '/Volumes/Data/models/models_r06'

# Read in extinction law)
extinction = Extinction.from_file('kmh94.par', columns=[0, 3],
                                  wav_unit=u.micron, chi_unit=u.cm**2 / u.g)

# Define filters and apertures
filters = ['2J', '2H', '2K', 'I1', 'I2', 'I3', 'I4']
apertures = [3., 3., 3., 3., 3., 3., 3.] * u.arcsec

# Run the fitting
fit('data_glimpse', filters, apertures, model_dir,
    'output.fitinfo',
    extinction_law=extinction,
    distance_range=[1., 2.] * u.kpc,
    av_range=[0., 40.])

Note

in the filter list, you can also specify wavelengths as Astropy Quantity instances. If you do this, the SED wavelength closest to that specified will be used in the fitting.

Note

if you do not specify the columns and units when reading in the extinction, the first two columns are read and are assumed to be in c.g.s.. If you have previously used the Fortran version of the SED fitter, you will need to specify columns=[0, 3] to choose the first and fourth column.

Plotting SEDs¶

Once you have fit the data, you will likely want to plot the resulting SED fits. To do this, you will need to make use of the plot() function, which can be imported with:

from sedfitter import plot

The plot() requires the output file from the fit() function as well as the name of an output directory. For example, continuing the example above, you can do:

from sedfitter import plot
plot('output.fitinfo', 'plots_seds')

By default, only the best-fit parameter is shown, but this can be changed by using the select_format option, which is described in more detail in Model selection syntax. For example, to write out all the models with a $\Delta\chi^2$ value per data point (relative to the best fit) of less than 3, you can do:

plot('output.fitinfo', 'plots_seds', select_format=('F', 3))

In addition, there are many options available to customize the format and appearance of the plots. For more information about these options, see the plot() page.

Plotting parameters¶

Functions are available to make 1- and 2-d parameter plots:

from sedfitter import plot_params_1d, plot_params_2d

As when Plotting SEDs, one needs to specify the output file from the fit() function, the output directory, and the name of the parameters to plot:

from sedfitter import plot_params_1d, plot_params_2d

# Make histograms of the disk mass
plot_params_1d('output.fitinfo', 'MDISK', 'plots_mdisk',
               log_x=True)

# Make 2-d plots of the envelope infall rate vs disk mass
plot_params_2d('output.fitinfo', 'MDISK', 'MDOT', 'plots_mdot_mdisk',
               log_x=True, log_y=True)

By default, only the best-fit parameter is shown, but this can be changed by using the select_format option, which is described in more detail in Model selection syntax. In addition, there are many options available to customize the format and appearance of the plots. For more information about these options, see the plot_params_1d() and plot_params_2d() pages.

Splitting well- and badly-fit sources¶

After computing the fits with fit(), it is possible to split the output file on the basis of the $\chi^2$ value for the best-fit. This is done using the filter_output() function which is imported with:

from sedfitter import filter_output

For example, to split the above file into well- and badly-fit sources based on the absolute $\chi^2$ of the best-fit, you can do:

filter_output('output.fitinfo', chi=3.)

This will produce files named output_good.fitinfo and output_bad.fitinfo by default (although you can also specify custom names for the output files). It is also possible to split the fits based on the $\chi^2$ value per datapoint using the cpd option. More information about the available options is available in filter_output().

Extracting the fit and model parameters¶

The output files produced above are in binary format and are not human-readable. To produce ASCII files of the output, you can use the write_parameters() and write_parameter_ranges() functions. The former is used to write out all the parameters of all the models requested, while the latter will only write out the minimum and maximum for each parameter. The functions are imported with:

from sedfitter import write_parameters, write_parameter_ranges

To use these functions, you will need to specify the input binary file, and the output ASCII file name:

from sedfitter import write_parameters, write_parameter_ranges

# Write out all models with a delta chi^2-chi_best^2 per datapoint < 3
write_parameters('output.fitinfo', 'parameters.txt',
                 select_format=('F', 3.))

# Write out the min/max ranges corresponding to the above file
write_parameter_ranges('output.fitinfo', 'parameter_ranges.txt',
                       select_format=('F', 3.))

More information about the available options is given in write_parameters() and write_parameter_ranges().

Convolving models with new filters¶

Preparing filters¶

This section describes how to convolve model packages with new filters. As described in the appendix Robitaille et al. (2007), there are a number of ways of defining filters/responses - for example one can define them as the fraction of photons that pass through the system, or the fraction of the energy that passes through the system. One also needs to understand what assumptions are being made to be able to quote a monochromatic flux for a broadband flux (for example, MIPS 24 micron fluxes typically assume that the underlying spectrum is a 10,000K blackbody).

The details of working out these assumptions is left to the user, and the Filter class used in the SED fitter requires that the user has already transformed and normalized the filter, such that the convolution can be done using the simple expression:

$F_\nu\rm{[quoted]} = \int F_\nu\rm{[actual]}\,R_\nu\,d\nu$

The filter class is imported using:

from sedfitter.filter import Filter

and should be instantiated as follows:

f = Filter()
f.name = ...
f.central_wavelength = ...
f.nu = ...
f.response = ...

for example:

f = Filter()
f.name = "NEW_FILT"
f.central_wavelength = 130. * u.micron
f.nu = np.logspace(12., 13., 100) * u.Hz
f.response = np.exp(-(np.log10(f.nu.value) - 12.5)**2 / (2. * 0.1)**2)

The filter can then be normalized (so that the integral over $\nu$ is 1) using:

f.normalize()

Once you have set up and normalized the filters, you are now ready to use the convolution functions.

Broadband convolution¶

Assuming that you have a model directory from Available Model Packages or Creating model packages, and filters prepared as described above, you can now use the convolve_model_dir() function to create the required convolved flux files. This function is used as:

from sedfitter.convolve import convolve_model_dir
convolve_model_dir(model_dir, filters)

where model_dir is a string containing the path to the models directory, and filters is a list of Filter instances for which you want to compute the convolved fluxes. For example, using the filter object from above:

convolve_model_dir('models_r06', [f])

This will then create new files in models_r06/convolved/, and you will then be able to use the filters for any further fitting.

Monochromatic ‘convolution’¶

In addition to conlving models with the SEDs, it is also possible to pretend that each wavelength for which the SEDs are defined can be associated with a delta function filter, and create a convolved flux file for each of these wavelengths. This can be done using:

from sedfitter.convolve import convolve_model_dir_monochromatic
filters = convolve_model_dir_monochromatic(model_dir)

This will return a table containing details about the ‘filters’ that have been created.

Object-oriented fitting interface¶

In addition to fitting via the fit() function, it is possible to make use of the Fitter class to load in all the models and set the fitting parameters, and then fit sources on-demand (this can be useful for GUI tools for example). To use the Fitter class, first instantiate the class by setting up the fit parameters, similarly to the fit() function, except that no data file or output file is passed to the Fitter class:

from astropy import units as u
from sedfitter import Fitter
from sedfitter.extinction import Extinction

# Define path to models
model_dir = '/Volumes/Data/models/models_r06'

# Read in extinction law)
extinction = Extinction.from_file('kmh94.par', columns=[0, 3],
                                  wav_unit=u.micron, chi_unit=u.cm**2 / u.g)

# Define filters and apertures
filters = ['2J', '2H', '2K', 'I1', 'I2', 'I3', 'I4']
apertures = [3., 3., 3., 3., 3., 3., 3.] * u.arcsec

# Run the fitting
fitter = Fitter(filters, apertures, model_dir,
                extinction_law=extinction,
                distance_range=[1., 2.] * u.kpc,
                av_range=[0., 40.])

To fit sources, you will then need to set up Source instances. You can either set up a Source instance with a single data file line:

from sedfitter.source import Source
s = Source.from_ascii('source_2 0.0 0.0 1 1 1 0.2 0.05 1.2 0.1 1.8 0.3')

or by instantiating the class and setting the parameters manually:

s = Source()
s.name = ...
s.x = ...

Once you have a Source instance, you can pass it to the fit() method:

info = fitter.fit(s)

The returned object is a FitInfo instance which can be passed instead of a filename to all the post-processing functions (such as plot()).

Appendices¶

Data format¶

The data file you will need to feed to the fitter should contain one source per line. Each line should contain 3*(n+1) columns, where n is the number of wavelengths/filters for which fluxes are given:

Column 1 should contain the source name, with no spaces
Columns 2 and 3 should contain the source coordinates
Columns 4 to 3+n should contain a flag for each flux, where the flag can take the following values:
- 0 for data points which are not valid or used
- 1 for valid data points
- 2 for lower limits
- 3 for upper limits
- 4 for valid data points (as for 1) but where the fluxes and errors are expressed as $\log_{10}{\rm [flux]}$ and $\log_{10}{\rm [error]}$ . This is useful for sources which have a magnitude with a large error, which can then be converted to $\log_{10}{\rm [flux]}$ and $\log_{10}{\rm [error]}$ without worrying about the conversion from magnitude and magnitude error to linear fluxes and errors.
Columns 4+n to 3*(n+1) should contain the fluxes and flux uncertainties, alternated, in mJy. For lower and upper limits, the error should be set to the confidence placed on the limit, with 0 corresponding to 0% and 1 corresponding to 100%. For example, in the case of an upper limit, setting the confidence to 1 effectively forbids any models to be larger than the upper limit, while setting the confidence between 0 and 1 allows such models, but introduces a $\chi^2$ penalty dependent on the confidence. Setting the confidence to 0 effectively disables the upper limit.

We refer to this format as the fitter data format. Note that in a single data file, all lines should have the same number of columns. If one or more fluxes are not available for a specific source, the flag for these fluxes can be set to 0.

An example data file with four fluxes per source is shown here:

SSTGLMC_G009.8925-00.3420 9.89250 -0.34200 1 1 1 1   6.869e+01   6.869e+00   1.512e+02   1.512e+01   1.626e+02   1.626e+01   9.015e+01   9.015e+00
SSTGLMC_G009.8940-00.3367 9.89408 -0.33675 0 0 1 1  -9.999e+02  -9.999e+02  -9.999e+02  -9.999e+02   7.412e+00   7.412e-01   1.199e+01   1.199e+00
SSTGLMC_G009.8943-00.3378 9.89430 -0.33783 0 0 1 1  -9.999e+02  -9.999e+02  -9.999e+02  -9.999e+02   4.462e+00   4.462e-01   6.927e+00   6.927e-01

Model selection syntax¶

Many of the functions in the SED fitter accept a tuple containing a single character string and a value. This tuple is used to indicate how many models to plot, output, keep, etc.

The character should indicate what kind of selection is being done, and the number quantifies the selection. The options are:

('A', value): select all models (value is ignored).
('N', value): select a fixed number of fits given by value.
('C', value): select all models with a $\chi^2$ below a threshold given by value.
('D', value): select all models with a $\chi^2-\chi^2_{\rm best}$ value below a threshold given by value.
('E', value): select all models with a $\chi^2$ per datapoint below a threshold given by value.
('F', value): select all models with a $\chi^2-\chi^2_{\rm best}$ value per datapoint below a threshold given by value.

Available Model Packages¶

Below you will find links to existing model packages that can be downloaded.

Robitaille et al. (2006) YSO SED Models¶

These are models that were published in Robitaille et al. (2006).

Important

Please read this disclaimer before downloading the models!

You are responsible for reading about the models and ensuring that you understand all the limitations inherent to YSO SED models in general, and this specific set of models. A number of caveats related to the models are listed in Section 2.2.4 of Robitaille et al. (2006) and a number of more general limitations are also discussed in Robitaille (2008).

In particular, it is very important to not over-interpret results carried out by fitting these models. The models are simple axisymmetric 2-D models, which are likely only a very rough approximation of reality, and the models should only be used accordingly. The $\chi^2$ value is thus not meaningful in the traditional statistical sense of being linked to a well-defined probability. The models also include strong correlations between parameters due to the way the parameters were sampled (this is described in more detail in the two publications linked above) and can therefore not be reliably used to search for real trends in datasets.

An example of a study using the models in the way they were intended (as rough probes of evolutionary stage), see Forbrich et al. (2010). In addition, an example of a study of the reliability of SED modeling for protostars with these models is presented in Offner et al. (2012).

By downloading the models, you acknowledge that you have read and agree with the above disclaimer

Download: models_r06_17jun08.tgz [5.3Gb]

Note

the default parameters.fits file contained in the above model package does not include the envelope mass. If you are interested in this parameter, you will need to download this file, decompress it, then put it inside the models_r06 directory and make sure it is named parameters.fits.

Castelli & Kurucz (2004) stellar photosphere models¶

These are the Castelli and Kurucz (2004) models downloaded from here and bundled into the model package format as a convenience.

Important

Please read this disclaimer before downloading the models!

These models are provided as a convenience, and no warranty is made on the accuracy of the models or of the conversion into model package format. It is your responsability to ensure that you understand the models and their limitations.

By downloading the models, you acknowledge that you have read and agree with the above disclaimer

Download: models_kurucz_05sep11.tgz [87Mb]

Creating model packages¶

This page describes the format required of a model package in order to be used by the fitter. The format adopted for all files is the FITS standard. All FITS files presented here should have BITPIX=-32 and EXTEND=T in the primary header. The model package should have a name starting with model_ and containing the following:

models.conf - a configuration file for the models.
seds/ - a directory containing all the model SEDs as fits or fits.gz files, in the format described below. In order to avoid huge numbers of files in a single directory, sub-directories can be created with a section of the model names. The size of this section can later be specified in the models Configuration file.
convolved/ - a directory containing all the convolved models, one file per filter. The name of the files should be filter.fits where filter should be replaced with the filter code (e.g. 2J, 2H, etc.).
parameters.fits.gz - the parameters for the models, in the same order as the convolved fluxes

Configuration file¶

The models.conf configuation file should be a plain-ASCII file containing the following keyword/value pairs:

The name of the model package:
```
name = YSO models
```
The length of the sub-directories for SED files:
```
length_subdir = 5
```
In cases where hundreds of thousands of SEDs are present, it is recommended to split them into sub-directories inside the seds directory. This is done by taking the first few letters of all the models and putting all the models that have the same first few letters in the same sub-directory, with the name of these first letters. The above option is the length of the sub-string to use for this. For example, if length_subdir is set to 5, all models starting with 30001 should be in a directory called 30001 inside seds/.
Whether the models are aperture/scale dependent:
```
aperture_dependent = yes
```
This should only be set to no if the models are not absolutely scaled to 1kpc, and if they are only specified in one aperture. In this case, the distance_range option to fit() is ignored.
The step in the distance, in log space. Model SEDs are computed for a range of distances between mind and maxd, uniformly spaced in log space, and separated by this value:
```
logd_step = 0.025
```

SED files¶

HDU 0¶

The primary header must contain following keywords:

VERSION  = 1   (integer) (the current version, in case we make big changes in future)
MODEL    = value (character) (the model name)
IMAGE    = T/F (logical) (whether images are available in HDU 0)
WAVLGHTS = T/F (logical) (whether wavelengths are available in HDU 1)
APERTURS = T/F (logical) (whether apertures are available in HDU 2)
SEDS     = T/F (logical) (whether SEDs are available in HDU 3)

If WAVLGHTS = T, then the header must contain:

NWAV = value (integer) which is the number of wavelengths

If APERTURS = T, then the header must contain:

NAP = value (integer) which is the number of apertures

If IMAGE = T, then this HDU should contain a data cube which is the model image as a function of wavelength. This will be specified in more detail in future.

HDU 1¶

if WAVLGTHS = T, this HDU should contain a 2-column binary table with NWAV values in each column. The first column should have the title WAVELENGTH, format 1E, and unit MICRONS. The second column should have the title FREQUENCY, format 1E, and unit HZ. Optionally, a third column can be included with the title STELLAR_FLUX, format 1E, and units specified appropriately. This column can be used to specify the model stellar photosphere used to compute YSO models for example. Only mJy and ergs/cm\^2/s are supported as units at this time. If specified, the stellar photosphere should have the correct scaling relative to the SEDs in HDU 3.

HDU 2¶

if APERTURS = T, this HDU should contain a 1-column binary table with NAP values. The column should have the title APERTURE, format 1E, and units AU. These are the apertures for which the SEDs in HDU 3 are tabulated.

HDU 3¶

if SED = T, this HDU should contain a binary table with at least one column, and HDU 1 and HDU 2 should also contain data. Each column should consist of NAP rows of real vectors with dimension NWAV. Thus, each cell contains an SED. The format of each column should be nE, where n=NWAV. The title and units of each column should be specified. The columns can contains SEDs such as the total flux, the stellar flux, the disk flux, etc. or related uncertainties. The following column titles are examples of ones that can be used:

TOTAL_FLUX
TOTAL_FLUX_ERR
STELLAR_FLUX
STELLAR_FLUX_ERR
DISK_FLUX
DISK_FLUX_ERR
ENVELOPE_FLUX
ENVELOPE_FLUX_ERR
DIRECT_FLUX
DIRECT_FLUX_ERR
SCATTERED_FLUX
SCATTERED_FLUX_ERR
THERMAL_FLUX
THERMAL_FLUX_ERR
etc.

The order of the columns is not important as there are FITS routines to search for a specific column.

Note

The SED fitter requires a column TOTAL_FLUX to be present, and will return an error otherwise. Only mJy and ergs/cm^2/s are supported as units at this time.

Convolved fluxes file¶

HDU 0¶

The primary header must contain following keywords:

FILTWAV  = value (real) (the characteristic wavelength of the filter)
NMODELS  = value (integer) (the number of models)
NAP      = value (integer) (the number of apertures)

HDU 1¶

This HDU should contain a 5-column binary table. The column titles should be:

MODEL_NAME
TOTAL_FLUX
TOTALF_FLUX_ERR
RADIUS_SIGMA_50
RADIUS_CUMUL_99

The first column should have format 30A and should contain the name of each model. No units are required. The second and third columns should have format nE where n=NAP, with each cell containing a vector with the fluxes in the different apertures. The fourth and fifth column should have format 1E and contain the outermost radius at which the surface brightness falls to 50% of the maximum surface brightness, and the radius inside which 99% of the flux is contained respectively. These two columns should have units AU.

HDU 2¶

This HDU should contain a 1-column binary table with NAP values. The column should have the title APERTURE, format 1E, and units AU. These are the apertures for which the fluxes in HDU 1 are tabulated.

Model parameters¶

HDU 0¶

The primary header must contain following keywords:

NMODELS  = value (integer) (the number of models)

HDU 1¶

This HDU should contain a binary table with the model parameters. Any number of columns can be included, in any order. Only parameters with format 1E will be usable by the programs to plot parameters, but text parameters with format nA can also be included (e.g. dust model filenames, etc.). One column is compulsory, with title MODEL_NAME and format 30A. It should contain the same names as the convolved fluxes file, and in the same order.

Common filter names¶

The filters for which convolved fluxes are available varies depending on the model package. However, The following list gives common filter names:

Short name	Filter
BU	Bessel U-Band
BB	Bessel B-Band
BV	Bessel V-Band
BR	Bessel R-Band
BI	Bessel I-Band
2J	2MASS J-Band
2H	2MASS H-Band
2K	2MASS K-Band
UL	UKIRT L-Band
LP	UKIRT L’-Band
UM	UKIRT M-Band
I1	IRAC Band [1]
I2	IRAC Band [2]
I3	IRAC Band [3]
I4	IRAC Band [4]
XA	MSX Band A
XC	MSX Band C
XD	MSX Band D
XE	MSX Band E
M1	MIPS 24
M2	MIPS 70
M3	MIPS 160
S1	IRAS 12 microns
S2	IRAS 25 microns
S3	IRAS 60 microns
S4	IRAS 100 microns
W1	Scuba 450WB microns
W2	Scuba 850WB microns
N1	Scuba 350NB microns
N2	Scuba 450NB microns
N3	Scuba 750NB microns
N4	Scuba 850NB microns

Detailed description of functions and arguments (API)¶

sedfitter Package¶

Functions¶

`extract_parameters`([input, output_prefix, …])
`filter_output`([input_fits, output_good, …])	Filter an output file into well and badly fit sources.
`fit`(data, filter_names, apertures, …[, …])	Fit a set of sources with models.
`plot`(input_fits[, output_dir, …])	Make SED plots
`plot_params_1d`(input_fits, parameter[, …])	Make histogram plots of parameters
`plot_params_2d`(input_fits, parameter_x, …)	Make histogram plots of parameters
`plot_source_data`(ax, source, filters[, …])
`validate_array`(name, value[, domain, ndim, …])
`write_parameter_ranges`(input_fits, output_file)	Write out an ASCII file with ranges of paramters for each source.
`write_parameters`(input_fits, output_file[, …])	Write out an ASCII file with the paramters for each source.

Classes¶

`Extinction`()
`FitInfoFile`(fits[, mode])
`Fitter`(filter_names, apertures, model_dir[, …])	A fitter class that can be used to fit sources.
`Models`()
`Source`()

sedfitter.sed Package¶

Classes¶

`BaseCube`([valid, names, distance, wav, nu, …])	A cube to represent a cube of models.
`PolarizationCube`([valid, names, distance, …])
`SED`()
`SEDCube`([valid, names, distance, wav, nu, …])

sedfitter.convolved_fluxes Package¶

Classes¶

`ConvolvedFluxes`([wavelength, model_names, …])
`MonochromaticFluxes`([wavelength, …])

sedfitter.extinction Package¶

Classes¶

Extinction()

sedfitter.fit_info Module¶

Classes¶

`FitInfo`([source])	Results from a fit of a set of models to a source.
`FitInfoFile`(fits[, mode])
`FitInfoMeta`

sedfitter.source Package¶

Classes¶

Source()

sedfitter.filter Package¶

Classes¶

Filter([name, central_wavelength, nu, response]) A filter used to convolve SED models.

sedfitter.convolve Package¶

Functions¶

`convolve_model_dir`(model_dir, filters[, …])	Convolve all the model SEDs in a model directory
`convolve_model_dir_monochromatic`(model_dir)	Convolve all the model SEDs in a model directory