pPXF

https://pypi.org/project/ppxf
Admin
pPXF is a Python implementation of the Penalized PiXel-Fitting method for full-spectrum fitting with...
Tokens:39,619
Snippets:310
Trust Score:10
Update:7 months ago
Show doc for...
Tokens:
Raw
### pPXF Multi-Component Start Values (Python)

Source: https://pypi.org/project/ppxf/9.4.5

Example of setting starting values for two kinematic components, where the first component fits 4 moments and the second fits 2 moments.

```python
component = [0, 0, ... 0, 1, 1, ... 1]
moments = [4, 2]
start = [[V1, sigma1], [V2, sigma2]]
```

--------------------------------

### Example: Configuring pPXF for Component Fitting

Source: https://pypi.org/project/ppxf

This example demonstrates how to configure the 'component' and 'moments' parameters in pPXF for fitting different kinematic components. It shows how to fix one component while fitting another, utilizing specific numbers of spectral templates and Gauss-Hermite moments.

```python
component = [0]*100 + [1]*5   # --> [0, 0, ... 0, 1, 1, 1, 1, 1]
moments = [-4, 2]
start = [[V, sigma, h3, h4], [V, sigma]]
```

--------------------------------

### Install ppxf package using pip

Source: https://pypi.org/project/ppxf/9.4.5

This command installs the ppxf package to version 9.4.5. It is a standard Python package installation command. Ensure pip is installed and updated for best results.

```bash
pip install ppxf==9.4.5
```

--------------------------------

### PPXF Systemic Velocity Calculation Example

Source: https://pypi.org/project/ppxf

Shows how to calculate the systemic velocity (vsyst) in PPXF, which is crucial for two-sided fitting. The example formula `vsyst = c*np.log(wave_temp[0]/wave_gal[0])` is used to account for wavelength differences between template and galaxy spectra. Alternatively, wavelengths can be passed directly.

```python
vsyst = c*np.log(wave_temp[0]/wave_gal[0])
```

--------------------------------

### pPXF LOSVD Start Values (Python)

Source: https://pypi.org/project/ppxf/9.4.5

Defines the initial guess for LOSVD parameters [velStart, sigmaStart] when moments are set to 4. If h3-h6 are fitted, they are initialized to zero.

```python
start = [velStart, sigmaStart]
```

--------------------------------

### pPXF LOSVD Start Values with Higher Moments (Python)

Source: https://pypi.org/project/ppxf/9.4.5

Illustrates how the 'start' array is interpreted when fitting more than 2 moments, automatically including zero for higher-order moments like h3 and h4.

```python
start = [velStart, sigmaStart, 0, 0]
```

--------------------------------

### PPXF Kinematic Component Tying Example

Source: https://pypi.org/project/ppxf

Demonstrates how to tie the Line-of-Sight Velocity Distribution (LOSVD) of two kinematic components in PPXF. While the 'tied' keyword can achieve this, using the 'component' keyword is a more efficient method for the same effect.

```python
p = [0, 0, 0, 0, 0, 0]
tied = [['', '', '', ''], ['', 'p[1]'], ['(p[0] + p[4])/2', '']]
# p[6] = (p[0] + p[4])/2
```

--------------------------------

### Initialize LOSVD Parameters (pPXF)

Source: https://pypi.org/project/ppxf

Defines the initial guess for Line-of-Sight Velocity Distribution (LOSVD) parameters in pPXF. The 'start' parameter can be a single vector or a list of vectors for multiple kinematic components. When fitting only velocity and dispersion, only these two values are needed.

```python
start = [velStart, sigmaStart]
```

```python
start = [velStart, sigmaStart, 0, 0]
```

```python
start = [[V1, sigma1], [V2, sigma2]]
```

--------------------------------

### Install ppxf package without global write access

Source: https://pypi.org/project/ppxf/9.4.5

This command installs the ppxf package for the current user only, which is useful when write access to the global site-packages directory is not available. It ensures the package is installed in a user-specific location.

```bash
pip install --user ppxf
```

--------------------------------

### Configure Kinematic Fitting with Fixed Parameters in pPXF

Source: https://pypi.org/project/ppxf/9.4.5

This example illustrates how to set up kinematic components and fix specific parameters during the pPXF fit. It shows how to define the number of moments for each component and how to specify which parameters (e.g., sigma) should remain fixed. Negative values in 'moments' are shown to be equivalent to fixing all parameters for that component.

```python
moments = [4, 2]
start = [[V1, sigma1, h3, h4], [V2, sigma2]]
fixed = [[0, 1, 0, 0], [0, 1]]
```

```python
moments = [-4, 2]
# Equivalent to:
moments = [4, 2]
fixed = [[1, 1, 1, 1], [0, 0]]
```

--------------------------------

### Dust Component Modeling in pPXF

Source: https://pypi.org/project/ppxf

Defines parameters for modeling dust attenuation in pPXF. It allows specifying starting values, bounds, and which components are affected by dust. A custom attenuation curve can also be provided.

```python
gas_component = component > 0   # assuming stars = 0 and gas = 1
dust_gas = {"start": [0.1], "bounds": [[0, 8]], "component": gas_component}
dust_stars = {"start": [0.1, -0.1], "bounds": [[0, 4], [-1, 0.4]], "component": ~gas_component}
dust = [dust_gas, dust_stars]
```

--------------------------------

### Setting Parameter Bounds for Kinematic Components (Python)

Source: https://pypi.org/project/ppxf

Defines lower and upper bounds for kinematic parameters when fitting multiple components. The structure mirrors the 'start' parameter, specifying a [lower, upper] pair for each kinematic parameter.

```python
moments = [4, 2]
start_stars = [V1, sigma1, 0, 0]
start_gas = [V2, sigma2]
start = [start_stars, start_gas]

bounds_stars = [[V1_lo, V1_up], [sigma1_lo, sigma1_up], [-0.3, 0.3], [-0.3, 0.3]]
bounds_gas = [[V2_lo, V2_up], [sigma2_lo, sigma2_up]]
bounds = [bounds_stars, bounds_gas]
```

--------------------------------

### pPXF Initialization and Usage

Source: https://pypi.org/project/ppxf

Initializes the pPXF object with spectral data and fitting parameters, then prints the best-fit kinematics and plots the results. Requires template spectra, observed spectrum, noise spectrum, velocity scale, and initial guesses for kinematics.

```python
from ppxf.ppxf import ppxf

pp = ppxf(templates, galaxy, noise, velscale, start, bias=None,
          bounds=None, clean=False, component=0, constr_templ=None,
          constr_kinem=None, degree=4, dust=None, fixed=None,
          fraction=None, ftol=1e-4, gas_component=None, gas_names=None,
          gas_reddening=None, gas_reddening_func=None,
          global_search=False, goodpixels=None, lam=None,
          lam_temp=None, linear=False, linear_method='lsq_box',
          mask=None, method='capfit', mdegree=0, moments=2, phot=None,
          plot=False, quiet=False, reddening=None, reddening_func=None,
          reg_dim=None, reg_ord=2, reg_step=None, regul=0,
          sigma_diff=0, sky=None, templates_rfft=None, tied=None,
          trig=False, velscale_ratio=1, vsyst=0, x0=None)

print(pp.sol)  # print best-fitting kinematics (V, sigma, h3, h4)
pp.plot()      # Plot best fit with gas lines and photometry
```

--------------------------------

### Assigning Templates to Kinematic Components (Python)

Source: https://pypi.org/project/ppxf

Specifies which kinematic component each input template belongs to when fitting multiple components. This is useful for differentiating between, for example, stellar and gas templates.

```python
component = [0]*50 + [1]*10
# Equivalent to: component = [0, 0, ... 0, 1, 1, ... 1]
```

--------------------------------

### Calculate Best Fit Template and Sky

Source: https://pypi.org/project/ppxf/9.4.5

Demonstrates how to compute the best-fitting galaxy template and sky spectrum using the weights obtained from the pPXF fitting process. It covers scenarios with and without sky fitting, and when sky weights differ for left and right spectra.

```python
import numpy as np

# Assuming 'templates', 'weights', 'sky', 'n_templates' are defined

# Case 1: No sky fitting
bestemp = templates @ weights

# Case 2: With sky fitting
bestemp = templates @ weights[:n_templates]
bestsky = sky @ weights[n_templates:]

# Case 3: Two-sided fitting with sky (alternating sky weights)
# The 'weights' array will contain interleaved weights for left/right sky spectra.
```

--------------------------------

### Upgrade ppxf package to the latest version

Source: https://pypi.org/project/ppxf/9.4.5

This command upgrades the ppxf package to its most recent version. It fetches the latest release from the Python Package Index (PyPI) and replaces the currently installed version.

```bash
pip install --upgrade ppxf
```

--------------------------------

### Selecting Linear Least-Squares Method in pPXF

Source: https://pypi.org/project/ppxf

Chooses the algorithm for solving the linear least-squares subproblem to determine template weights. Options include 'nnls', 'lsq_box' (default), 'lsq_lin', and 'cvxopt'. The choice can impact computational speed and support for inequality constraints.

```python
linear_method='cvxopt'
```

```python
linear_method='lsq_lin'
```

--------------------------------

### Log Rebin Wavelength Calculation using ppxf.ppxf_util

Source: https://pypi.org/project/ppxf

Demonstrates how to obtain restframe wavelength values after applying the log_rebin utility from ppxf_util. This is typically used when the 'lam' keyword is required for spectral fitting, especially when dealing with reddening or dust parameters.

```python
from ppxf.ppxf_util import log_rebin
specNew, ln_lam, velscale = log_rebin(lamRange, galaxy)
lam = np.exp(ln_lam)
```

--------------------------------

### Define Dust Attenuation Curve Parameters

Source: https://pypi.org/project/ppxf

Configures dust attenuation curves to be applied to specific sets of templates. Each element in the 'dust' list is a dictionary specifying parameters like bounds, component assignment, fixed status, function type, and starting values for the attenuation curve.

```python
dust_params = {"bounds": (0.1, 5.0), "component": 0, "fixed": False, "func": "Fitzpatrick99", "start": 2.0}
dust = [dust_params]
```

--------------------------------

### Use Pre-computed Template FFTs (Python)

Source: https://pypi.org/project/ppxf

Allows passing the real FFT of templates, computed in a previous pPXF call. This is an advanced option for users who understand its implications and want to optimize repeated calls with identical templates.

```python
templates_rfft: optional

When calling pPXF many times with an identical set of templates, one can use this keyword to pass the real FFT of the templates, computed in a previous pPXF call, stored in the pp.templates_rfft attribute. This keyword mainly exists to show that there is no need for it…
IMPORTANT: Use this keyword only if you understand what you are doing!
```

--------------------------------

### Define Dust Attenuation Curve Parameters in pPXF

Source: https://pypi.org/project/ppxf/9.4.5

Configures dust attenuation curves for specific template components. Each dust parameter set is a dictionary specifying bounds, component assignment, fixed status, function type, and starting values for the attenuation curve.

```python
dust_1 = {"bounds": (0.1, 5.0), "component": 0, "fixed": False, "func": "Fitzpatrick99", "start": 1.0}
dust_2 = {"bounds": (0.1, 5.0), "component": 1, "fixed": False, "func": "Calzetti01", "start": 1.5}
dust = [dust_1, dust_2]
```

--------------------------------

### Setting Parameter Bounds in pPXF

Source: https://pypi.org/project/ppxf/9.4.5

Defines lower and upper bounds for kinematic parameters in pPXF fits. The structure of 'bounds' must match 'start', with each parameter having a [lower, upper] pair. This is crucial for multi-component fits where different components may have different parameter ranges.

```python
moments = [4, 2]
start_stars = [V1, sigma1, 0, 0]
start_gas = [V2, sigma2]
start = [start_stars, start_gas]

bounds_stars = [[V1_lo, V1_up], [sigma1_lo, sigma1_up],
                [-0.3, 0.3], [-0.3, 0.3]]
bounds_gas = [[V2_lo, V2_up], [sigma2_lo, sigma2_up]]
bounds = [bounds_stars, bounds_gas]
```

--------------------------------

### pPXF Main Function

Source: https://pypi.org/project/ppxf

The `ppxf` function is the core of the package, used to fit templates to observed spectra (and optionally photometry) to extract kinematic and population information.

```APIDOC
## pPXF Main Function

### Description
Extract the galaxy stellar and gas kinematics, stellar population and gas emission by fitting a set of templates to an observed spectrum, or to a combination of a spectrum and photometry (SED), via full-spectrum fitting. It uses the Penalized PiXel-Fitting (pPXF) method.

### Method
`ppxf`

### Parameters
#### Positional Arguments
- **templates** (array) - Input templates.
- **galaxy** (array) - Observed galaxy spectrum.
- **noise** (array) - Noise spectrum.
- **velscale** (float) - Velocity scale of the spectra.
- **start** (array) - Initial guesses for the fit parameters.

#### Keyword Arguments
- **bias** (float, optional) - Bias for the fit.
- **bounds** (tuple, optional) - Bounds for the fit parameters.
- **clean** (bool, optional) - Whether to clean the spectrum.
- **component** (int, optional) - Component to fit (default: 0).
- **constr_templ** (array, optional) - Constraints on templates.
- **constr_kinem** (array, optional) - Constraints on kinematics.
- **degree** (int, optional) - Degree of the additive polynomial (default: 4).
- **dust** (object, optional) - Dust model.
- **fixed** (array, optional) - Fixed parameters.
- **fraction** (float, optional) - Fraction parameter.
- **ftol** (float, optional) - Tolerance for the fit (default: 1e-4).
- **gas_component** (int, optional) - Gas component to fit.
- **gas_names** (list, optional) - Names of gas emission lines.
- **gas_reddening** (float, optional) - Reddening for gas emission lines.
- **gas_reddening_func** (function, optional) - Reddening function for gas emission lines.
- **global_search** (bool, optional) - Whether to perform a global search.
- **goodpixels** (array, optional) - Pixels to include in the fit.
- **lam** (array, optional) - Wavelengths of the galaxy spectrum.
- **lam_temp** (array, optional) - Wavelengths of the templates.
- **linear** (bool, optional) - Whether to use linear fitting.
- **linear_method** (str, optional) - Method for linear fitting (default: 'lsq_box').
- **mask** (array, optional) - Mask for the fit.
- **method** (str, optional) - Fitting method (default: 'capfit').
- **mdegree** (int, optional) - Degree of the multiplicative polynomial (default: 0).
- **moments** (int, optional) - Number of moments to fit (default: 2).
- **phot** (object, optional) - Photometric data.
- **plot** (bool, optional) - Whether to plot the results.
- **quiet** (bool, optional) - Whether to suppress output.
- **reddening** (float, optional) - Reddening for stellar population.
- **reddening_func** (function, optional) - Reddening function for stellar population.
- **reg_dim** (int, optional) - Dimension for regularization.
- **reg_ord** (int, optional) - Order for regularization (default: 2).
- **reg_step** (float, optional) - Step for regularization.
- **regul** (float, optional) - Regularization parameter.
- **sigma_diff** (float, optional) - Sigma difference for iterative sigma clipping.
- **sky** (array, optional) - Sky spectrum.
- **templates_rfft** (array, optional) - FFT of templates.
- **tied** (array, optional) - Tied parameters.
- **trig** (bool, optional) - Trigonometric parameter.
- **velscale_ratio** (float, optional) - Velocity scale ratio.
- **vsyst** (float, optional) - Systemic velocity (default: 0).
- **x0** (array, optional) - Initial guess for parameters.

### Request Example
```python
from ppxf.ppxf import ppxf

# Assuming templates, galaxy, noise, velscale, start are defined
# pp = ppxf(templates, galaxy, noise, velscale, start, degree=4, mdegree=0)
```

### Response
#### Success Response (200)
- **sol** (array) - Best-fitting kinematics (V, sigma, h3, h4).

#### Response Example
```json
{
  "sol": [100.0, 200.0, 0.0, 0.0]
}
```

### Additional Information
- Example programs are located in the `ppxf/examples` subdirectory.
- These examples can be opened as Jupyter Notebooks.
- Jupyter Notebook formatted examples with outputs are available on the GitHub repository.
```

--------------------------------

### Define Regularization Step Sizes (reg_step)

Source: https://pypi.org/project/ppxf

Defines the step sizes for numerical estimation of derivatives during pPXF regularization. Allows for custom step sizes across different dimensions and intervals.

```python
# Default step size of one for all dimensions: reg_step = [np.ones(rd - 1) for rd in reg_dim]
# Custom step sizes: provide a list of arrays, each of length reg_dim[j] - 1.
```

--------------------------------

### Enforcing Linear Constraints on Kinematics in pPXF

Source: https://pypi.org/project/ppxf/9.4.5

Specifies linear constraints on kinematic parameters using inequality (A_ineq @ params <= b_ineq) and equality (A_eq @ params == b_eq) conditions. The starting guess must satisfy these constraints. This is powerful for enforcing physical relationships between parameters, like velocity dispersion ratios.

```python
constr_kinem = {"A_ineq": A_ineq, "b_ineq": b_ineq, "A_eq": A_eq, "b_eq": b_eq}

# Example: sigma1 >= 3*sigma2
moments = [2, 2]
start = [[V1, sigma1], [V2, sigma2]]
A_ineq = [[0, -1, 0, 3]]  # 0*V1 - 1*sigma1 + 0*V2 + 3*sigma2 <= 0
b_ineq = [0]
constr_kinem = {"A_ineq": A_ineq, "b_ineq": b_ineq}

# Example: sigma1 >= sigma2 + 2*velscale
A_ineq = [[0, -1, 0, 1]]  # -sigma1 + sigma2 <= -2*velscale
b_ineq = [-2]             # kinem. in pixels (-2 --> -2*velscale)!
constr_kinem =  {"A_ineq": A_ineq, "b_ineq": b_ineq}

# Example: V1 >= V2 and sigma1 >= sigma2 + 2*velscale
A_ineq = [[-1, 0, 1, 0],   # -V1 + V2 <= 0
          [0, -1, 0, 1]]   # -sigma1 + sigma2 <= -2*velscale
b_ineq = [0, -2]           # kinem. in pixels (-2 --> -2*velscale)!
constr_kinem =  {"A_ineq": A_ineq, "b_ineq": b_ineq}

# Example: sigma1/1.1 <= sigma2 <= sigma1*1.1
A_ineq = [[0, 1/1.1, 0, -1],   # +sigma1/1.1 - sigma2 <= 0
          [0, -1.1,  0,  1]]   # -sigma1*1.1 + sigma2 <= 0
b_ineq = [0, 0]
constr_kinem =  {"A_ineq": A_ineq, "b_ineq": b_ineq}

# Example with multiple components and moments
moments = [4, 2, 2]
start = [[V1, sigma1, 0, 0], [V2, sigma2], [V3, sigma3]]
```

--------------------------------

### Define Photometry Parameters Dictionary

Source: https://pypi.org/project/ppxf

This snippet shows how to define the 'phot' dictionary, which holds parameters for fitting photometric data. It includes keys for templates, galaxy measurements, noise, and wavelengths.

```python
phot = {"templates": phot_templates, "galaxy": phot_galaxy,
        "noise": phot_noise, "lam": phot_lam}
```

--------------------------------

### Visualize Galaxy and Template Match

Source: https://pypi.org/project/ppxf/9.4.5

Provides Python code to visualize a galaxy spectrum and a template spectrum, allowing for a visual inspection of their match before running pPXF. It includes options for applying Gaussian smoothing and pixel shifts to the template.

```python
import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage

# Assuming 'galaxy' and 'template' are numpy arrays representing spectra

sigma = 2       # Velocity dispersion in pixels for smoothing
shift = -20     # Velocity shift in pixels

# Apply smoothing and shift to the template
template_shifted = np.roll(ndimage.gaussian_filter1d(template, sigma), shift)

# Plotting
plt.plot(galaxy, 'k', label='Galaxy')
plt.plot(template_shifted * np.median(galaxy) / np.median(template), 'r', label='Template')
plt.legend()
plt.show()
```

--------------------------------

### Visualize Galaxy and Template Spectra

Source: https://pypi.org/project/ppxf

Plots a galaxy spectrum against a template spectrum, allowing for visual inspection of wavelength ranges and velocity scales. This helps in identifying potential issues before running the pPXF fitting procedure.

```python
import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage

sigma = 2       # Velocity dispersion in pixels
shift = -20     # Velocity shift in pixels
template = np.roll(ndimage.gaussian_filter1d(template, sigma), shift)
plt.plot(galaxy, 'k')
plt.plot(template*np.median(galaxy)/np.median(template), 'r')
```

--------------------------------

### Normalize Templates by Median (Python)

Source: https://pypi.org/project/ppxf

Scales all spectral templates by their median value to ensure unity order of magnitude. This is crucial for linear regularization and to avoid numerical instabilities when relative fluxes are important.

```python
templates /= np.median(templates)
```

--------------------------------

### Global Optimization Options for pPXF

Source: https://pypi.org/project/ppxf

Enables a global optimization step before the standard local optimization in pPXF. This is useful for complex scenarios with multiple local chi2 minima, such as fitting distinct kinematic components. It can be set to True for default options or configured with a dictionary for scipy.optimize.differential_evolution.

```python
global_search=True
```

```python
global_search={'tol': 0.05, 'disp': 0}
```

--------------------------------

### Plotting pPXF Fit Results

Source: https://pypi.org/project/ppxf

Generates a plot of the best fit from the pPXF routine. Options allow for scaling based on stellar continuum alone, including/excluding galaxy spectrum and photometry.

```python
pp.plot()
pp.plot(gas_clip=True)
pp.plot(spec=True)
pp.plot(phot=True)
pp.plot(phot=True, spec=False)
pp.plot(phot=False, spec=True)
```

--------------------------------

### Kinematic Component Fitting in pPXF

Source: https://pypi.org/project/ppxf

Specifies how kinematic components are fitted in pPXF. The 'moments' parameter defines the number of moments for each component, and 'fixed' allows fixing specific kinematic parameters. Negative values in 'moments' can be used as a shortcut to fix all parameters of a component.

```python
moments = [4, 2]
start = [[V1, sigma1, h3, h4], [V2, sigma2]]

# Example of fixing sigma for both components
fixed = [[0, 1, 0, 0], [0, 1]]

# Equivalent to fixing all parameters for the first component
moments = [-4, 2]
fixed = [[1, 1, 1, 1], [0, 0]]
```

--------------------------------

### Normalize Individual Templates by Median (Python)

Source: https://pypi.org/project/ppxf

Normalizes each spectral template independently by its median value. This is applicable when using individual stars as templates, where their relative fluxes are generally irrelevant.

```python
templates /= np.median(templates, 0)
```

--------------------------------

### Calculate Best Fit Template and Sky

Source: https://pypi.org/project/ppxf

Calculates the best-fitting template and sky spectra by applying weights to the provided templates and sky data. This is useful for understanding the contribution of each component to the final fit.

```python
bestemp = templates @ weights

bestemp = templates @ weights[:n_templates]
bestsky = sky @ weights[n_templates:]
```

--------------------------------

### Performing a Linear Fit with pPXF

Source: https://pypi.org/project/ppxf

Configures the pPXF fitting routine to perform a purely linear fit. In this mode, all non-linear parameters are held constant, and only the template weights and additive polynomials are fitted. This results in a solution that is a direct copy of the input, with zero errors.

```python
linear=True
```

--------------------------------

### Apply Linear Regularization with regul

Source: https://pypi.org/project/ppxf

Applies first or second-order linear regularization to the weights during the pPXF fit. Higher 'regul' values result in smoother weights.

```python
# regul > 0 applies regularization. regul=0 means no regularization.
# The solution is a trade-off between smoothness of weights and goodness of fit.
```

--------------------------------

### PPXF Output Attributes Reference

Source: https://pypi.org/project/ppxf

Detailed explanations of the attributes returned by the ppxf function, which provide insights into the spectral fitting results.

```APIDOC
## PPXF Output Attributes Reference

This section details the attributes available after a successful execution of the `ppxf` function. These attributes provide access to the results of the spectral fitting process.

### `.gas_zero_template`

**Description:** A boolean vector indicating which gas templates resulted in a zero contribution within the fitted region. For these components, flux and error are set to NaN.

**Type:** `numpy.ndarray` (boolean)

### `.goodpixels`

**Description:** An integer vector containing the indices of pixels that were considered good (i.e., not outliers) during the fit. This is derived from the input `goodpixels` and updated if outlier rejection is enabled.

**Type:** `numpy.ndarray` (integer)

### `.matrix`

**Description:** The design matrix used in the least-squares fitting. It comprises polynomial basis functions, stellar/gas templates, and sky spectra.

**Shape:** `(n_pixels, npoly + n_templates + n_sky)`

**Components:**
- `pp.matrix[:,: npoly]`: Additive polynomial basis functions.
- `pp.matrix[:, npoly: npoly + n_templates]`: Convolved stellar and/or gas templates.
- `pp.matrix[:, npoly + n_templates :]`: Sky spectra, if included.

**Type:** `numpy.ndarray`

### `.mpoly`

**Description:** The best-fitting multiplicative polynomial. If `reddening` is set, this represents the best-fitting reddening curve (A_V).

**Type:** `numpy.ndarray` or `float`

### `.mpolyweights`

**Description:** Coefficients of the multiplicative Legendre polynomials (when `mdegree > 0`). Largely superseded by `.mpoly`.

**Usage:** Can be used to reconstruct the multiplicative polynomial using `numpy.polynomial.legendre.legval` or `pp.trigval` if `trig=True`.

**Type:** `numpy.ndarray`

### `.phot_bestfit`

**Description:** The best-fitting fluxes in the photometric bands, provided that `phot` was supplied as input.

**Type:** `numpy.ndarray`

### `.plot`

**Description:** A function to generate a plot of the best-fit spectrum. Can be called after `ppxf` execution as an alternative to `plot=True` during the call.

**Usage:**
- `pp.plot(gas_clip=True)`: Scales plot based on stellar continuum, allowing gas lines to exceed limits.
- `pp.plot(..., spec=True)`: Includes the galaxy spectrum.
- `pp.plot(..., phot=True)`: Includes photometric measurements.

**Type:** `function`

### `.polyweights`

**Description:** Weights of the additive Legendre polynomials (when `degree >= 0`). Largely superseded by `.apoly`.

**Usage:** Can be used to reconstruct the additive polynomial using `numpy.polynomial.legendre.legval` or `pp.trigval` if `trig=True`.

**Type:** `numpy.ndarray`

### `.reddening`

**Description:** The best-fitting A_V value if the `reddening` keyword was enabled during the fit.

**Type:** `float`

### `.sol`

**Description:** A vector containing the best-fitting kinematic parameters.

**Contents:**
- `moments=2`: `[Vel, Sigma]`
- `moments=4`: `[Vel, Sigma, h3, h4]`
- `moments=N`: `[Vel, Sigma, h3, ..., hN]`

**Multi-component fits:** If multiple kinematic components are fitted, `.sol` will be a list containing the solutions for each component sequentially.

**Note:** `Vel = c*np.log(1 + z)`. See Cappellari (2017) for details.

**Type:** `numpy.ndarray` or `list`
```
Tokens:
Raw