mangadap.proc.ppxffit module¶
Implements a wrapper class for pPXF.
Todo
Allow new iteration mode that iteratively fits until the velocity is not up against one of the +/ 2000 km/s limits? Could be useful for poor redshift guesses.
Revision history¶
26 Apr 2016: Moved from spectralfitting.py to its own file by K. Westfall (KBW)05 Jul 2016: (KBW) V6.0.0 of pPXF does not use the oversample keyword given a better solution; see Cappellari (in prep). This keyword was therefore removed from the parameter set.06 Jul 2016: (KBW) Use v6.0.0 pPXF functions to compute models using new LOSVD kernel functionality.10 Oct 2016: (KBW) Fixed error in calculation of velocity offset between template and object spectra to account for different size pixels.31 Oct 2016: (KBW) Allow the spectral resolution to be a vector per spaxel or a vector per set of input spectra inPPXFFit.fit()
.01 Nov 2016: (KBW) Added new iteration method that does not do a first fit to the global spectrum but does include the rejection iteration. Allows users to treat each spectrum provided toPPXFFit.fit()
individually. Fixed goodpixel mask when not first fitting the global spectrum.02 Nov 2016: (KBW) Added ability to limit which templates are fit to each spectrum inPPXFFit.fit()
using usetpl kwarg.17 Feb 2017: (KBW) Included filtering options. Changed to use ppxf v6.0.4; mpfit object no longer returned, only mpfit status.30 Aug 2017: (KBW) Switch frommangadap.util.instrument.resample_vector()
tomangadap.util.instrument.resample1d()
.05 Feb 2018: (KBW) AddedPPXFModel
.22 May 2018: (KBW) Change import to ppxf package.30 Aug 2018: (KBW) Changed from resample1d tomangadap.util.sampling.Resample
.
Copyright © 2019, SDSSIV/MaNGA Pipeline Group

class
mangadap.proc.ppxffit.
PPXFFit
(bitmask, par=None)[source]¶ Bases:
mangadap.proc.spectralfitting.StellarKinematicsFit
Use pPXF to measure the stellar kinematics. Although it can also fit the composition and emission lines, for now just force it to be a
StellarKinematicsFit
objec.
bitmask
¶ Bitmask to use for masking spectral pixels and parameter values. For
fit_SpatiallyBinnedSpectra()
, must have bit for ‘LOW_SNR’. Forfit()
must have bits for ‘TPL_PIXELS’, ‘TRUNCATED’, ‘PPXF_REJECT’, ‘LARGE_CHI2’, ‘LARGE_RESID’, ‘INSUFFICIENT_DATA’, ‘FIT_FAILED’, ‘NEAR_BOUND’.Type: BitMask

_check_mode
(iteration_mode, reject_boxcar, filter_boxcar, filter_operation, filter_iterations, mdegree)[source]¶

_fit_all_spectra
(templates, templates_rfft, tpl_to_use, plot=False, plot_file_root=None)[source]¶ Fit all spectra provided.
 Get an initial fit
 Reject
 Mask and smooth templates and objects
 Fit ratio
 Mask and smooth
 Fit ratio
 Fit unmasked with fixed kinematics to get models (with emission lines?)

_fit_dispersion_correction
(templates, templates_rfft, result, baseline_dispersion=None)[source]¶  Calculate the dispersion correction:
 Construct the optimized, redshifted template without the convolution with the bestfitting LOSVD.
 Convolve it with the resolution difference in the data.
 Use pPXF to fit the matched version to the unmatched version; this should be the dispersion correction.
Todo
Decide how to deal with regions below 2pixel resolution in synthetic spectrum being fit. How does this alter the correction?

_fit_global_spectrum
(obj_to_include=None, plot=False)[source]¶  Fit the global spectrum. This:
 Sets the baselevel good pixel mask for the fits to the individual bins
 Gives the template weights for the global template
Todo
 Only include spectra above a given S/N in global spectrum?
 Allow for a number of iterations as input.

_is_near_bounds
(result, guess_velocity, tol_frac=0.01)[source]¶ Check if the fitted kinematics are near the imposed limits.
The definition of “near” is that the velocity and higher moments cannot be closer than the provided fraction of the total width to the boundary. For the velocity dispersion, the fraction is done in log space.

_matched_mask_filter
(bf, obj_mask, tpl_flux, tpl_rfft, tpl_to_use, result)[source]¶ self.tpl_npad must exist!

_nominal_dispersion_correction
(obj_sres, gpm, cz)[source]¶ Calculate the dispersion corrections as the quadrature difference between the spectral resolution of the template and object spectra. Returns a masked array!

_run_fit_iteration
(obj_flux, obj_ferr, start, end, base_velocity, tpl_flux, tpl_rfft, guess_kin, fix_kinematics=False, obj_to_fit=None, tpl_to_use=None, degree=None, mdegree=None, dof=None, weight_errors=False, plot=False)[source]¶ Fit all the object spectra in obj_flux.
Todo
 Calculate DOF in this function?
 Explicitly set the bounds to use instead of using the pPXF defaults?
Parameters:  obj_flux (numpy.ma.MaskedArray) – Size is \(N_{\rm spec}\times N_{\rm chan}\), object spectra.
 obj_ferr (numpy.ma.MaskedArray) – Size is \(N_{\rm spec}\times N_{\rm chan}\), object errors
 start (array) – Size is \(N_{\rm spec}\), starting pixel for each spectrum
 end (array) – Size is \(N_{\rm spec}\), ending pixel (+1) for each spectrum
 base_velocity (array) – Size is \(N_{\rm spec}\), base velocity offset between each object spectrum and the template spectra.
 tpl_flux (array) – Size is \(N_{\rm tpl}\times N_{\rm tpl chan}\), template spectra
 tpl_rfft (array) – Size is \(N_{\rm tpl}\times N_{\rm tpl pad}\), real FFT of the template spectra
 guess_kin (array) – Initial guess for kinematics. Size is \(N_{\rm spec}\times N_{\rm moments}\).
 fix_kinematics (bool) – (Optional) Flag to fix the kinematics to the input values during the fit.
 obj_to_fit (array) – (Optional) Size is \(N_{\rm spec}\), boolean flag to fit object spectrum
 tpl_to_use (array) – (Optional) Size is \(N_{\rm spec}\times N_{\rm tpl}\), boolean flag to use a template for the fit to each object spectrum
 plot (bool) – (Optional) Produce the default ppxf fit plot.
 degree (int) – (Optional) Additive polynomial order.
Default is to use the internal attribute
degree
.  mdegree (int) – (Optional) Multiplicative polynomial
order. Default is to use the internal attribute
mdegree
.  dof (int) – (Optional) Number of degrees of freedom in
the fit. Default is to use the internal attribute
dof
.
Returns: Array with \(N_{\rm spec}\) instances of
PPXFFitResult
.Return type: numpy.ndarray

_validate_kinematics
(model_mask, model_par)[source]¶ Validate the returned kinematics.
 Checks:
 corrected velocity dispersion must be in the range 50400 km/s

static
check_objects
(obj_wave, obj_flux, obj_ferr=None, obj_sres=None)[source]¶ Check that the input object data is valid for use with pPXFFit.
Parameters:  obj_wave (numpy.ndarray) – 1D vector of object wavelengths in angstroms. Does NOT need to be same as the template wavelengths.
 obj_flux (numpy.ndarray) – \(N_{\rm spec}\times N_{\rm pix}\) array of object spectra to fit. Can be a numpy.ma.MaskedArray.
 obj_ferr (numpy.ndarray) – (Optional) \(N_{\rm spec}\times N_{\rm pix}\) array with the errors in the object spectra. Can be a numpy.ma.MaskedArray.
 obj_sres (numpy.ndarray) – (Optional) 1D or 2D array with the spectral resolution (\(R = \lambda/\Delta\lambda\)) at each wavelength for (each of) the object spectra. Default is the resolution is not provided and assumed to be same as the template resolution.

static
check_pixel_scale
(tpl_wave, obj_wave, velscale_ratio=None, dvtol=1e10)[source]¶ Confirm that the pixel scale of the template and object spectra are identical within a certain tolerance, accounting for an input pixelscale ratio. Returns the velocity scale of the object spectra and the velocity scale ratio wrt the template spectra.

static
check_templates
(tpl_wave, tpl_flux, tpl_sres=None, velscale_ratio=None)[source]¶ Check that the input template data is valid for use with pPXFFit.

static
compile_model_flux
(obj_flux, ppxf_result, rescale=False)[source]¶ Return the model flux but pulling the models out of the ppxf results. The model can be rescaled to the data based on the fitted pixels if rescale is True.
The output array is masked in the spectral regions below and above the fitted wavelength range; any intervening pixels are not masked, even if they’re not included in the fit.

static
construct_models
(tpl_wave, tpl_flux, obj_wave, obj_flux_shape, model_par, select=None, redshift_only=False, deredshift=False, corrected_dispersion=False, dvtol=1e10)[source]¶ Construct models using the provided set of model parameters. This is a wrapper for
PPXFModel
.Only the shape of the object data is needed, not the data itself.
Allows for a replacement template library that must have the same shape as
tpl_flux
.The input velocities are expected to be cz, not “ppxf” (pixelized) velocities.
If redshift_only is true, the provided dispersion is set to 1e9 km/s, which is numerically identical to 0 (i.e., just shifting the spectrum) in the tested applications. However, beware that this is a HARDCODED number.
Warning
This will not work if the parameters are the result of a filtered fit! (iteration_mode = ‘fit_reject_filter’)
To convolve the model to the corrected dispersion, instead of the uncorrected dispersion, set corrected_dispersion=True. Correction always uses SIGMACORR_EMP data.

static
convert_velocity
(v, verr)[source]¶ Convert kinematics from pPXF from pixel shifts to redshifts. pPXF determines the velocity offset by making the approximation that every pixel (logarithmically binned in wavelength) is a constant change in velocity. Over large velocity shifts, this approximation can become poor. An email summary from Michele Cappellari:
The velocity scale per pixel is input as
\[\delta v = c \delta\ln\lambda = c (\ln\lambda_1  \ln\lambda_0)\]The velocites output by pPXF are:
\[V = \delta V N_{\rm shift} = c \ln(\lambda_{N_{\rm shift}}/\lambda_0)\]which implies that the relation between PPXF output velocity and redshift is
\[1 + z = exp(V/c),\]which reduces z~vel/c in the lowredshift limit. This function converts the \(V\) values provided by pPXF to \(cz\) velocities.
Note
IMPORTANT: After this conversion, you must revert the velocities back to the “pixelbased velocities” (using
_revert_velocity()
) before using the velocities to reconstruct the pPXF fitted model.

fit
(tpl_wave, tpl_flux, obj_wave, obj_flux, obj_ferr, guess_redshift, guess_dispersion, iteration_mode='global_template', reject_boxcar=100, filter_boxcar=100, filter_operation='divide', filter_iterations=0, ensemble=True, velscale_ratio=None, mask=None, usetpl=None, matched_resolution=True, tpl_sres=None, obj_sres=None, waverange=None, bias=None, degree=4, mdegree=0, filt_degree=4, filt_mdegree=0, moments=2, loggers=None, quiet=False, max_velocity_range=400.0, alias_window=None, dvtol=1e10, plot=False, plot_file_root=None)[source]¶ Wrapper for pPXF with some additional convenience functions. Limited implementation at the moment.
Parameters:  tpl_wave (numpy.ndarray) – 1D vector of template wavelengths at rest in angstroms.
 tpl_flux (numpy.ndarray) – Ntemplates x Nwavelengths array of template spectra to fit.
 obj_wave (numpy.ndarray) – 1D vector of object wavelengths in angstroms. Does NOT need to be same as the template wavelengths.
 obj_flux (numpy.ndarray) – Nspec x Nwavelengths array of object spectra to fit. Can be a numpy.ma.MaskedArray.
 obj_ferr (numpy.ndarray) – Nspec x Nwavelengths array with the errors in the object spectra.
 guess_redshift (
float
, numpy.ndarray) – Single or spectrumspecific redshift used to set the initial guess kinematics.  guess_dispersion (
float
, numpy.ndarray) – Single or spectrumspecific velocity dispersion used to set the initial guess kinematics.  iteration_mode (
str
, optional) – Iteration sequence to perform. Seeiteration_modes()
.  reject_boxcar (
int
, optional) – Size of the boxcar to use during the rejection iteration. Default is 100. If None, rejection uses the entire residual spectrum.  filter_boxcar (
int
, optional) – Size of the boxcar to use when filtering the spectra. Cannot be None.  filter_iterations (
int
, optional) – Number of filtering iterations for the ‘fit_reject_filter’ iteration mode.  ensemble (
bool
, optional) – Treat the list of input spectra as an ensemble. Currently, this only affects how the spectra are masked. Default is to treat them as an ensemble. When not treated as an ensemble, each spectrum is masked individually according to the input wavelength range and velocity offsets. It does not make sense to set the iteration_mode to something that will include a fit to the global spectrum if you’re not treating the list of object spectra as an ensemble.  velscale_ratio (
int
, optional) – Ratio of velocity scale per pixel in the object spectra to that for the template spectra. Default is that they should be identical.  mask (numpy.ndarray,
mangadap.util.pixelmask.SpectralPixelMask
, optional) – A baseline pixel mask to use during the fitting. Other pixels may be masked via the convenience functions, but these pixels will always be masked.  matched_resolution (
bool
, optional) – Flag that the object and template spectra have identical spectral resolution. Default is True.  tpl_sres (numpy.ndarray, optional) – Onedimensional vector with the spectral resolution (\(R = \lambda/\Delta\lambda\)) at each wavelength of the template spectra. Default is the resolution is not provided and assumed to be same as the object resolution.
 obj_sres (numpy.ndarray, optional) – One or Twodimensional array with the spectral resolution (\(R = \lambda/\Delta\lambda\)) at each wavelength for (each of) the object spectra. Default is the resolution is not provided and assumed to be same as the template resolution.
 waverange (arraylike, optional) – Lower and upper wavelength limits to include in the fit. This can be a twoelement vector to apply the same limits to all spectra, or a Nspec x 2 array with wavelength ranges for each spectrum to be fit. Default is to use as much of the spectrum as possible.
 bias (
float
, optional) – From the pPXF documentation: This parameter biases the (h3, h4, …) measurements towards zero (Gaussian LOSVD) unless their inclusion significantly decreases the error in the fit. Set this to BIAS=0.0 not to bias the fit: the solution (including [V, sigma]) will be noisier in that case. The default BIAS should provide acceptable results in most cases, but it would be safe to test it with Monte Carlo simulations. This keyword precisely corresponds to the parameter lambda in the Cappellari & Emsellem (2004) paper. Note that the penalty depends on the relative change of the fit residuals, so it is insensitive to proper scaling of the NOISE vector. A nonzero BIAS can be safely used even without a reliable NOISE spectrum, or with equal weighting for all pixels.  degree (
int
, optional) – From the pPXF documentation: degree of the additive Legendre polynomial used to correct the template continuum shape during the fit (default: 4). Set DEGREE = 1 not to include any additive polynomial.  mdegree (
int
, optional) –From the pPXF documentation: degree of the multiplicative Legendre polynomial (with mean of 1) used to correct the continuum shape during the fit (default: 0). The zero degree multiplicative polynomial is always included in the fit as it corresponds to the weights assigned to the templates. Note that the computation time is longer with multiplicative polynomials than with the same number of additive polynomials.
Note
IMPORTANT: Multiplicative polynomials cannot be used when the REDDENING keyword is set.
 filt_degree (
int
, optional) – The order of the additive polynomial to use when fitting the filtered spectra.  filt_mdegree (
int
, optional) – The order of the multiplicative polynomial to use when fitting the filtered spectra.  moments (
int
, optional) –From the pPXF documentation: Order of the GaussHermite moments to fit. Set this keyword to 4 to fit [h3, h4] and to 6 to fit [h3, h4, h5, h6]. Note that in all cases the GH moments are fitted (nonlinearly) together with [V, sigma].
 If MOMENTS=2 or MOMENTS is not set then only [V, sigma] are fitted and the other parameters are returned as zero.
 If MOMENTS is negative then the kinematics of the given COMPONENT are kept fixed to the input values.
 EXAMPLE: We want to keep fixed component 0, which has an LOSVD described by [V, sigma, h3, h4] and is modelled with 100 spectral templates; At the same time we fit [V, sigma] for COMPONENT=1, which is described by 5 templates (this situation may arise when fitting stellar templates with predetermined stellar kinematics, while fitting the gas emission). We should give in input to ppxf() the following parameters: component = [0]*100 + [1]*5 # –> [0, 0, …, 0, 1, 1, 1, 1, 1] moments = [4, 2] start = [[V, sigma, h3, h4], [V, sigma]]
 loggers (
list
, optional) – List of logging.Logger objects to log progress; ignored if quiet=True. Logging is done usingmangadap.util.log.log_output()
. Default is no logging.  quiet (
bool
, optional) – Suppress all terminal and logging output. Default is False.  max_velocity_range (
float
, optional) – Maximum range (+/) expected for the fitted velocities in km/s.  alias_window (
float
, optional) – The window to mask to avoid aliasing near the edges of the spectral range in km/s. Default is six times max_velocity_range.  dvtol (
float
, optional) – The velocity scale of the template spectra and object spectrum must be smaller than this tolerance.  plot (
bool
, optional) – Show the automatically generated pPXF fit plots.
Returns: Returns 4 numpy.ndarray objects:
 The wavelengths of the best fitting model spectra. Nominally the same as the wavelengths of the input object spectra (obj_wave).
 The fluxes of the bestfitting model spectra.
 A mask for the bestfitting models spectra, following from the internal bitmask.
 A record array with the fitted model parameters; see
spectralfitting.StellarKinematicsFit._per_stellar_kinematics_dtype
.
Return type: tuple
Raises: ValueError
– Raised if the input arrays are not of the correct shape or if the pixel scale of the template and object spectra is greater than the specified tolerance.

fit_SpatiallyBinnedSpectra
(binned_spectra, par=None, loggers=None, quiet=False, debug=False)[source]¶ This is a basic interface that is geared for the DAP that interacts with the rest of the, more general, parts of the class.
This should not declare anything to self!

static
fitting_mask
(tpl_wave, obj_wave, velscale, velscale_ratio=None, waverange=None, velocity_offset=None, max_velocity_range=400.0, alias_window=None, loggers=None, quiet=False)[source]¶ Return a list of pixels in the object spectrum to be fit using pPXF.
Be clear between velocity (ppxf) vs. redshift (cz) !
The limits applied to the fitted pixels are:
 Apply the provided wavelength range limit (waverange).
 pPXF will only allow a fit when the number of template pixels is the same as or exceeds the number of pixels in the object spectrum. The first step toward limiting template spectra that are too long is to truncate the blue and red edges that likely won’t be used given the provided velocity offsets (velocity_offset) and the expected velocity range (max_velocity_range).
 Remove leading and trailing pixels that will cause alias problems during the convolution with the LOSVD (alias_window).
Parameters:  obj_wave (array) – Wavelength vector of the object spectrum to be fit.
 tpl_wave (array) – Wavelength vector of the template library to fit to the object spectrum.
 velscale (float) – Velocity scale of the pixel.
 velscale_ratio (int) – (Optional) Ratio of the object velscale to the template velscale. Default is 1 (i.e. the two have the same pixel scale).
 waverange (array) – (Optional) Lower and upper wavelength limits to include in the analysis. The array can either define a single wavelength range – shape is (2,) – or a set of wavelength ranges – shape is (n,2). Default is to apply no wavelength range limitation.
 velocity_offset (array) – (Optional) Vector with the velocity offset (expected or actual) between the template and the object spectrum in km/s. Used to estimate which wavelengths can be removed from the template. This can be a single offset or a set of offsets. If both waverange and velocity_offset are 2D arrays, the number of wavelength ranges and offsets must be the same. Default is that there is no velocity offset.
 max_velocity_range (float) – (Optional) Maximum range (+/) expected for the fitted velocities in km/s. Default is 400 km/s.
 alias_window (float) – (Optional) The window to mask to avoid aliasing near the edges of the spectral range in km/s. Default is six times max_velocity_range.
 loggers (list) – (Optional) List of logging.Logger
objects to log progress; ignored if quiet=True. Logging
is done using
mangadap.util.log.log_output()
. Default is no logging.  quiet (bool) – (Optional) Suppress all terminal and logging output. Default is False.
Returns: Four boolean vectors are returned:
 flags for pixels to include in the fit
 flags for pixels that were excluded because they were outside the designated wavelength range
 flags for pixels that were excluded to ensure the proper length of the template spectrum wrt the object spectrum.
 flags for pixels that were truncated to avoid convolution aliasing
Return type: numpy.ndarray
Raises: ValueError
– Raised if (1) no pixels are valid for the fit, (2) the template and object do not have overlapping spectral regions given the expected velocity offset between the two, or (3) the turncation to deal with aliasing removes all remaining pixels.

static
initialize_model_mask
(obj_wave, obj_flux, mask=None, bitmask=None, velocity_offset=None)[source]¶

static
initialize_pixels_to_fit
(tpl_wave, obj_wave, obj_flux, obj_ferr, velscale, velscale_ratio=None, waverange=None, mask=None, bitmask=None, velocity_offset=None, max_velocity_range=400.0, alias_window=None, ensemble=True, loggers=None, quiet=False)[source]¶ obj_flux and obj_ferr must be masked arrays.
Todo
 This function can alter obj_flux and obj_ferr !! Return them instead?

static
iteration_modes
()[source]¶ Possible iteration methods:
none
: Fit all bins with all templates with a single call to pPXF.fit_reject_filter
: Perform the following procedure: Fit each spectrum
 for n iterations:
 Reject outliers
 Filter the object and template spectra
 Fit the filtered spectra
 Fit the unfiltered spectra with the kinematics fixed to result of the final filtered fit
no_global_wrej
: Do not fit the global spectrum first, but include a rejection iteration. All templates are fit in each step.global_template
: Fit the global spectrum with all templates and include a single rejection iteration. The pixel mask for this fit is the base mask for all fits to the individual bins. A single rejection iteration is done for each bin. Only the global template is used when fitting each bin.nonzero_templates
: Fit the global spectrum with all templates and include a single rejection iteration. The pixel mask for this fit is the base mask for all fits to the individual bins. A single rejection iteration is done for each bin. Only the templates with nonzero weights are used when fitting each bin.all_templates
: Fit the global spectrum with all templates and include a single rejection iteration. The pixel mask for this fit is the base mask for all fits to the individual bins. A single rejection iteration is done for each bin. All templates are used when fitting each bin.Returns: List of allowed options. Return type: list

static
losvd_limits
(velscale)[source]¶ Return the limits on the LOSVD parameters used by pPXF.
 Velocity limits are \(\pm 2000\) km/s
 Velocitydisperison limits are from 1/10 pixels to 1000 km/s
 Limits of the higher orders moments are from 0.3 to 0.3

static
obj_tpl_pixelmatch
(velscale, tpl_wave, velscale_ratio=None, dvtol=1e10)[source]¶ Confirm that the pixel scale of the template and object data are the same within some tolerance, accounting for and input ratio of the two.

static
ppxf_tpl_obj_voff
(tpl_wave, obj_wave, velscale, velscale_ratio=None)[source]¶ Determine the pseudo offset in velocity between the template and object spectra, just due to the difference in the starting wavelengths.
This calculation is independent of the base of the logarithm used the sampling of the spectra.
Assumes wavelengths are logarithmically binned.
Parameters:  tpl_wave (numpy.ndarray) – Wavelength vector for the template library to fit to the object spectrum.
 obj_wave (numpy.ndarray) – Wavelength vector for the object spectrum to be fit.
 velscale (float) – Velocity step per pixel in km/s for the object spectrum.
 velscale_ratio (int) – (Optional) The integer ratio between the velocity scale of the pixel in the galaxy data to that of the template data. This is used only when constructing the template library. Default is None, which is the same as assuming that the velocity scales are identical.
Returns: Velocity offset in km/s between the initial wavelengths of the template and object spectra.
Return type: float
Todo
 Implement a check that calculates the velocity ratio directly?

static
reconstruct_model
(tpl_wave, templates, obj_wave, kin, weights, velscale, polyweights=None, mpolyweights=None, start=None, end=None, redshift_only=False, sigma_corr=0.0, velscale_ratio=None, dvtol=1e10, revert_velocity=True)[source]¶ Construct a pPXF model spectrum based on a set of input spectra and parameters.
This function is outdated! Use :func:`construct_models` or :class:`PPXFModel` instead.

rej_flag
= 'PPXF_REJECT'¶

static
reject_model_outliers
(obj_flux, ppxf_result, rescale=False, local_sigma=False, boxcar=None, nsigma=3.0, niter=9, loggers=None, quiet=False)[source]¶

static
revert_velocity
(v, verr)[source]¶ Revert the velocity back to the “pixelized” velocity returned by pPXF.
Order matters here. The error computation is NOT a true error propagation; it’s just the inverse of the “convert” operation

rng_flag
= 'OUTSIDE_RANGE'¶

snr_flag
= 'LOW_SNR'¶

tpl_flag
= 'TPL_PIXELS'¶

trunc_flag
= 'TRUNCATED'¶


class
mangadap.proc.ppxffit.
PPXFFitPar
(template_library_key=None, template_library=None, guess_redshift=None, guess_dispersion=None, iteration_mode=None, reject_boxcar=None, filter_boxcar=None, filter_operation=None, filter_iterations=None, match_resolution=None, velscale_ratio=None, minimum_snr=None, pixelmask=None, bias=None, degree=None, mdegree=None, filt_degree=None, filt_mdegree=None, moments=None)[source]¶ Bases:
mangadap.par.parset.KeywordParSet
Define a parameter set used by the pPXF fitting method.
Todo
The overlap between this and
mangadap.proc.stellarcontinuummodel.StellarContinuumModelDef
is not well designed.The defined parameters are:
Key Type Options Default Description template_library_key
str Keyword of the library to fit. See mangadap.proc.templatelibrary.available_template_libraries()
.template_library
TemplateLibrary Object with the spectra in the template library that have been prepared for analysis of the data. guess_redshift
ndarray, list, int, float Initial guess for the redshift (\(cz\)) of each binned spectrum. guess_dispersion
ndarray, list, int, float Initial guess for the velocity dispersion for each binned spectrum. iteration_mode
str none
,fit_reject_filter
,no_global_wrej
,global_template
,nonzero_templates
,all_templates
global_template
Iteration mode to use; see PPXFFit.iteration_modes()
.reject_boxcar
int Number of pixels in the boxcar used to determine the local sigma for rejecting outliers. filter_boxcar
int Size of the boxcar in pixels used in a highpass filter applied before fitting the spectra. (To be deprecated) filter_operation
str divide
,subtract
divide
Operation to use when constructing the filtered spectra. The boxcar smoothed version of the spectrum is either subtracted or divided into the original spectrum if filter_operation
issubtract
ordivide
, respectively. (To be deprecated)filter_iterations
int 0 Number of fitrejectfilter iterations. (To be deprecated) match_resolution
bool True Match the spectral resolution of the template to that of the galaxy data. This is used only when constructing the template library. Default is True. velscale_ratio
int The integer ratio between the velocity scale of the pixel in the galaxy data to that of the template data. This is used only when constructing the template library. Default is None, which is the same as assuming that the velocity scales are identical. minimum_snr
int, float Minimum S/N ratio to include in the fitting. pixelmask
PixelMask Pixel mask to include during the fitting. bias
int, float ppxf bias
parameter used to penalize low S/N spectra toward a Gaussian LOSVD.degree
int 8 ppxf degree
parameter used to set the order of the additive polynomial to include in the fit.mdegree
int 0 ppxf mdegree
parameter used to set the order of the multiplicative polynomial to include in the fit.filt_degree
int 8 Order of the additive polynomial to include when fitting highpass filtered spectra. (To be deprecated) filt_mdegree
int 0 Order of the multiplicative polynomial to include when fitting highpass filtered spectra. (To be deprecated) moments
int 2, 4, 6 2 ppxf moments
parameter used to set the number of moments of the LOSVD to fit. The DAP has not been well tested for fits that include any more than \(V\) and \(\sigma\).

class
mangadap.proc.ppxffit.
PPXFFitResult
(degree, mdegree, start, end, tpl_to_use, ppxf_fit, ntpl, weight_errors=False, component_fits=False)[source]¶ Bases:
object
A basic utility to save the critical parts of the pPXF model.

class
mangadap.proc.ppxffit.
PPXFModel
(templates, galaxy, velscale, velscale_ratio=None, vsyst=None, sigma_diff=0, moments=2, degree=4, mdegree=0, component=0, gas_component=None, lam=None, reddening=None, gas_reddening=None, reddening_func=None, sky=None, templates_rfft=None, trig=False, quiet=False)[source]¶ Bases:
object
Class that reconstructs a pPXF model given a set of templates and the model parameters.
This pulls functions from M. Cappellari’s ppxf class, version 6.7.0.
Input common to ppxf() input should have the same format as pPXF input.
The only reason the galaxy spectrum (or spectra) are provided is to set if the data are to fit as reflectionsymmetric and how many spectral pixels there are.

construct
(kin, tplwgts, addpoly=None, multpoly=None, reddening=None, gas_reddening=None)[source]¶ Construct a pPXF model spectrum provided the input parameters. Mostly a copy of ppxf._linear_fit().
Parameters:  kin (list, numpy.ndarray) – Must have the kinematics of each component. Must be a list or array of vectors with a shape (NCOMP,). The length of each vector in the list/array must be the same as MOMENTS.
 tplwgts (numpy.ndarray) – Weights to apply to each template. Shape must be (NTEMP,).
 addpoly (numpy.ndarray) – (Optional) Coefficients of the additive polynomials. Shape must be (NSPEC*(DEGREE+1),). Exception is raised if coefficients are expected (self.degree > 1), but no coefficiencts are provided.
 multpoly (numpy.ndarray) – (Optional) Coefficients of the multiplicative polynomials. Shape must be (NSPEC*MDEGREE,). Exception is raised if coefficients are expected (self.mdegree > 0), but no coefficiencts are provided.
 reddening (float) – (Optional) E(BV) value for the continuum fit. Exception is raised if value is expected (self.reddening is not None), but none is provided.
 gas_reddening (float) – (Optional) E(BV) value for the gas components. Exception is raised if value is expected (self.reddening is not None), but none is provided.
Returns: Return type: numpy.ndarray
