MaNGA Data Analysis Pipeline

https://sdss-mangadap.readthedocs.io/en/latest/
Admin
The MaNGA Data Analysis Pipeline (DAP) is a survey-led software package that analyzes galaxy data...
Tokens:984,577
Snippets:6,269
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Setup pPXF Component for Kinematic Fitting

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/contrib/xjmc.html

Sets up kinematic components, moments, and starting points for pPXF fitting, with options to consolidate gas components.

```python
def _ppxf_component_setup(component, moments, gas_template, start, fixed,
                          single_gas_component=False, gas_start=None):
    """
    Setup the component, moment, and starting point arrays for a
    ppxf-fitting iteration.

    This primarily just sets all the gas components to a single component if
    requested, restructuring the moment, starting point, and fixed parameter
    arrays as necessary to reflect this change.

    ..warning::

        This function requires that all stellar components have
        component numbers that are **less than** any gas components.
        However, this **is not checked** by the function.

    Args:
        component (`numpy.ndarray`_):
            1D array with the full list of components for all templates.  Shape
            is ``(ntpl,)``.  The maximum value is ``ncomp-1``.
        moments (`numpy.ndarray`_):
            1D array with the number of moments for each kinematic component.
            Shape is ``(ncomp,)``.
        gas_template (`numpy.ndarray`_):
            A boolean array identifying the gas templates.  Shape is ``(ntpl,)``.
        start (`numpy.ndarray`_):
            2D array with the starting kinematics to use for each object
            spectrum.  Shape is ``(nobj,sum(moments))``.
        fixed (`numpy.ndarray`_):
            Boolean array selecting kinematic component that should be fixed
            during the fit.  Each spectrum is fit the same, meaning the shape is
            the same as the 2nd axis of ``start``: ``(sum(moments),)``.
        single_gas_component (:obj:`bool`, optional):
            Flag to force all gas components to have the same kinematics.
        gas_start (`numpy.ndarray`_, optional):
            Array with the starting kinematics to use for the gas components.
            Shape must be ``(nobj,2)``.

    Returns:
        :obj:`tuple`: Three numpy arrays are returned:

            #. The list of down-selected and renumbered, if necessary,
               kinematic components,

            #. the down-selected and reordered, if necessary, number
               of moments to fit,

            #. the down-selected and reordered starting guesses for
               each component, and

            #. the down-selected and reordered fixed moments for
               each component.

    Raises:
        ValueError:
            Raised if the provided gas starting kinematics is not
            correct.
    """
    if not single_gas_component and gas_start is None:
        # Function does nothing
        return component.copy(), moments.copy(), start.copy(), fixed.copy()

    # Number of object spectra to fit
    nobj = start.shape[0]

    if gas_start is not None and gas_start.shape != (nobj,2):
        raise ValueError('Provided gas starting kinematics has incorrect shape.')

    # Get the gas and stellar  component numbers
    gas_components, str_components = split_components(component, gas_template)

    # Component assignments for each template
    _component = component.copy()
    str_template = np.logical_not(gas_template)
    n_gas_components = 1 if single_gas_component else len(gas_components)
    if single_gas_component:
        _component[gas_template] = np.amax(component[str_template])+1 if np.any(str_template) 
                                    else 0
    _gas_components = np.unique(_component[gas_template])

    # Shape of start is (nobj,); each element of start has shape (ncomp,);
    # each component has shape (nmom,), which can be different for each
    # component
    # Get the indices of the stellar kinematic parameters
    str_p = kin_indices(moments, str_components)

    # Update the moments and the "fixed" vectors
    _moments = moments.copy()
    _fixed = fixed.copy()
    if single_gas_component:
        # NOTE: This is fine if stellar_components is an empty list
        # TODO: Somehow propagate any fixed gas components instead of setting to False?
        _fixed = np.concatenate((_fixed[str_p], [False,False]))
        _moments = np.append(_moments[str_components], [2])

    # Copy over the stellar kinematics
    _start = np.zeros((nobj,np.sum(_moments)), dtype=float)
    _start[:,str_p] = start[:,str_p]

    _gas_v_p = vel_indices(_moments, select=_gas_components)
    _gas_d_p = _gas_v_p + 1
    if single_gas_component:
        if gas_start is None:
            gas_v_p = vel_indices(moments, select=gas_components)
            gas_d_p = gas_v_p + 1
            _start[:,_gas_v_p] = np.mean(start[:,gas_v_p], axis=1).reshape(nobj,1)
            _start[:,_gas_d_p] = np.mean(start[:,gas_d_p], axis=1).reshape(nobj,1)
        else:

```

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

### Example Emission Line Parameter File

Source: https://sdss-mangadap.readthedocs.io/en/latest/emissionlines.html

An example of an SDSS-style parameter file for emission lines, demonstrating the 'DAPEML' structure with sample data for various lines like OII, Hb, NII, and Ha.

```c
DAPEML   2  OII     3727.092   vac  f  { None   None }  {   34      = }  {    2      = }  {  3706.3  3716.3 }  {  3738.6  3748.6 }
DAPEML   3  OII     3729.875   vac  f  { None   None }  {    2      = }  {    2      = }  {  3706.3  3716.3 }  {  3738.6  3748.6 }
DAPEML  23  Hb      4862.6830  vac  f  { None   None }  {   34      = }  {   34    1.4 }  {  4798.9  4838.9 }  {  4885.6  4925.6 }
DAPEML  33  NII     6549.86    vac  f  {   35  =0.34 }  {   35      = }  {   35      = }  {  6483.0  6513.0 }  {  6623.0  6653.0 }
DAPEML  34  Ha      6564.608   vac  f  { None   None }  { None   None }  { None   None }  {  6483.0  6513.0 }  {  6623.0  6653.0 }
DAPEML  35  NII     6585.27    vac  f  { None   None }  {   34      = }  { None   None }  {  6483.0  6513.0 }  {  6623.0  6653.0 }
```

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

### Example Emission Line Database Entries

Source: https://sdss-mangadap.readthedocs.io/en/latest/emissionlines.html

Provides example entries for an emission-line database, illustrating both active and dummy configurations for moment parameters.

```text
DAPELB   2  OIId    3728.4835  vac  { 3716.3  3738.3 } { 3706.3  3716.3 } { 3738.6  3748.6 }
DAPELB   3  OII     3729.875   vac  {   -1      -1   } {   -1      -1   } {   -1      -1   }


```

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

### _ppxf_component_setup

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/contrib/xjmc.html

Sets up component, moment, and starting point arrays for ppxf fitting, managing gas and stellar components.

```APIDOC
## _ppxf_component_setup

### Description
Sets up the component, moment, and starting point arrays for a ppxf-fitting iteration. This function restructures the moment, starting point, and fixed parameter arrays to reflect the desired configuration of gas and stellar components, particularly when forcing all gas components to share single kinematics.

### Arguments
- `component` (numpy.ndarray): 1D array with the full list of components for all templates. Shape is `(ntpl,)`. The maximum value is `ncomp-1`.
- `moments` (numpy.ndarray): 1D array with the number of moments for each kinematic component. Shape is `(ncomp,)`.
- `gas_template` (numpy.ndarray): A boolean array identifying the gas templates. Shape is `(ntpl,)`.
- `start` (numpy.ndarray): 2D array with the starting kinematics for each object spectrum. Shape is `(nobj,sum(moments))`.
- `fixed` (numpy.ndarray): Boolean array selecting kinematic components to be fixed during the fit. Shape is `(sum(moments),)`.
- `single_gas_component` (bool, optional): Flag to force all gas components to have the same kinematics. Defaults to `False`.
- `gas_start` (numpy.ndarray, optional): Array with the starting kinematics for the gas components. Shape must be `(nobj,2)`. Defaults to `None`.

### Returns
tuple: A tuple containing four numpy arrays:
    1. The list of down-selected and renumbered kinematic components.
    2. The down-selected and reordered number of moments to fit.
    3. The down-selected and reordered starting guesses for each component.
    4. The down-selected and reordered fixed moments for each component.

### Raises
ValueError: If the provided gas starting kinematics has an incorrect shape.

### Warning
This function requires that all stellar components have component numbers that are **less than** any gas components. This condition is **not checked** by the function.
```

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

### Setup Guess Parameters and Bounds

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/elric.html

Sets up the initial guess parameters, fixed parameters, and bounds for spectral fitting. Includes logic for bounding line means within fitting windows.

```python
                # Setup the guess parameters and bounds
                _guess_par = numpy.array([ p.par.copy().ravel() 
                                            for p in self.fitting_window[j].profile_set ]).ravel()
                _fixed_par = self.fitting_window[j].fixed_par.ravel().copy()
                _bounds = self.fitting_window[j].bounds.copy().reshape(-1,2)
#                print(_guess_par)
#                print(_fixed_par)
#                print(_bounds)
```

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

### Generated DAP batch execution script

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/execution.rst.txt

This is an example of a script generated by `rundap` for executing the DAP and associated QA plots for a specific plate-ifu. It includes steps for marking the start and completion of the process.

```bash
# Auto-generated batch file
# Wed 06 Apr 2022 15:15:26

touch /path/for/dap/output/drpver/dapver/log/06Apr2022T22.15.26UTC/7443/12701/mangadap-7443-12701-LOGCUBE.started

OMP_NUM_THREADS=1 manga_dap -c /path/for/dap/output/drpver/dapver/common/7443/12701/mangadap-7443-12701-LOGCUBE.ini -o /path/for/dap/output/drpver/dapver --log /path/for/dap/output/drpver/dapver/log/06Apr2022T22.15.26UTC/7443/12701/mangadap-7443-12701-LOGCUBE.log -vv

OMP_NUM_THREADS=1 dap_ppxffit_qa -c /path/for/dap/output/drpver/dapver/common/7443/12701/mangadap-7443-12701-LOGCUBE.ini -o /path/for/dap/output/drpver/dapver -b 2.5

OMP_NUM_THREADS=1 spotcheck_dap_maps -c /path/for/dap/output/drpver/dapver/common/7443/12701/mangadap-7443-12701-LOGCUBE.ini -o /path/for/dap/output/drpver/dapver -b 2.5

OMP_NUM_THREADS=1 dap_fit_residuals -c /path/for/dap/output/drpver/dapver/common/7443/12701/mangadap-7443-12701-LOGCUBE.ini -o /path/for/dap/output/drpver/dapver -b 2.5

touch /path/for/dap/output/drpver/dapver/log/06Apr2022T22.15.26UTC/7443/12701/mangadap-7443-12701-LOGCUBE.done
```

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

### Setup for pPXF Component Fitting

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/contrib/xjmc.html

Sets up the components and initial parameters for the pPXF fitting routine, specifically handling single gas components.

```python
    component, moments, start, fixed \
            = _ppxf_component_setup(_component, _moments, _gas_template, _start, _fixed,
                                    single_gas_component=True)
```

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

### Get Unique Bin Indices for Stellar Kinematics

Source: https://sdss-mangadap.readthedocs.io/en/latest/gettingstarted.html

This example demonstrates how to extract unique bin indices for stellar kinematics from a DAP MAPS file using `DAPFitsUtil.unique_bins`. It specifically targets the second channel of the 'BINID' extension, which corresponds to attempted stellar kinematics fits.

```python
#Imports
import numpy
from astropy.io import fits
from mangadap.util.fitsutil import DAPFitsUtil

# Read a DAP MAPS file
hdu = fits.open('manga-8138-12704-MAPS-HYB10-MILESHC-MASTARSSP.fits.gz')

# Get the unique indices of the stellar-kinematics bins
ubins, uindx = DAPFitsUtil.unique_bins(hdu['BINID'].data[1], return_index=True)

```

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

### Instantiate EmissionLineDB from Key

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.par.emissionlinedb.html

Demonstrates how to load a predefined emission line database using its keyword.

```APIDOC
## Instantiate EmissionLineDB from Key

### Description
This code snippet shows how to instantiate an `EmissionLineDB` object using a predefined keyword, loading one of the default emission-line databases available with the MaNGA DAP.

### Method Signature
```python
EmissionLineDB.from_key(key)
```

### Parameters
* **key** (str) - The keyword identifying the emission-line database to load (e.g., 'ELPMPL9').

### Returns
An `EmissionLineDB` object containing the specified emission-line database.

### Request Example
```python
from mangadap.par.emissionlinedb import EmissionLineDB
print(EmissionLineDB.available_databases())
emldb = EmissionLineDB.from_key('ELPMPL9')
```
```

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

### Install SDSS-MANGADAP using Pip

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/installation.rst.txt

Install the SDSS-MANGADAP package directly from pip. This is the recommended method for most users.

```console
pip install sdss-mangadap
```

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

### Binning Function Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.spatiallybinnedspectra.html

Example signature for a binning function. It takes coordinates and parameters, returning the bin ID for each spectrum.

```python
id = bin(x, y, par=par)
```

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

### Setup Component for pPXF Fit

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/contrib/xjmc.html

Sets up components for a pPXF fit, including handling gas and stellar components and initializing kinematic estimates. This is a preparatory step before the main fitting iteration.

```python
gas_components, str_components = split_components(_component, _gas_template)
    except:
        embed(header='xjmc 1764')
        exit()
    strt = np.sum(np.absolute(moments[str_components]))
    gas_start = kin[:,strt:] if constr_kinem is None else None
    component, moments, start, fixed \
            = _ppxf_component_setup(_component, _moments, _gas_template, _start, _fixed,
                                    gas_start=gas_start)
```

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

### Redshift Fix File Format Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/metadatamodel.rst.txt

Example lines from the redshift-fix parameter file, specifying plate, ifudesign, and replacement redshift.

```c
DAPZCORR  9677  6102 0.0
DAPZCORR  9677  6103 0.0
...
```

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

### BitMask Class Initialization

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.util.bitmask.html

Demonstrates how to instantiate the BitMask class with a list of keys and optional descriptions. It also shows how to initialize from a configuration file or a FITS header.

```APIDOC
## Class mangadap.util.bitmask.BitMask

### Description
Generic class to handle and manipulate bitmasks. The input list of bit names (keys) must be unique, except that values of ‘NULL’ are ignored. The index in the input keys determines the bit value; ‘NULL’ keys are included in the count.

### Parameters
* **keys** (`str`, `list`) – List of keys (or single key) to use as the bit name. Each key is given a bit number ranging from 0..N-1.
* **descr** (`str`, `list`, optional) – List of descriptions (or single description) provided by `info()` for each bit. No descriptions by default.

### Raises
* **ValueError** – Raised if more than 64 bits are provided.
* **TypeError** – Raised if the provided keys do not have the correct type.

### Example: Basic Initialization
```python
from mangadap.util.bitmask import BitMask
keys = [ 'key1', 'key2', 'NULL', 'NULL', 'key3' ]
bm = BitMask(keys)
print(bm.info())
```

### Example: Initialization from INI file
```python
from mangadap.util.bitmask import BitMask
bm = BitMask.from_ini_file('imagebitmask.ini')
```

### Example: Initialization from FITS Header
```python
from astropy.io import fits
from mangadap.util.bitmask import BitMask
hdr = fits.Header()
# Assume image_bm is an instance of ImageBitMask
# image_bm.to_header(hdr)
copy_bm = BitMask.from_header(hdr)
```
```

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

### Install Development Dependencies

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/installation.rst.txt

Install development dependencies for the MANGADAP package, typically used when contributing to the code. Note that quotation marks may be shell-dependent.

```console
pip install -e ".[dev]"
```

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

### Setup Emission Line Database

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/emissionlinemodel.html

Initializes the emission line database from a specified key and path. The number of emission lines is derived from the database size.

```python
self.emldb = None if self.method['emission_lines'] is None else \
                        EmissionLineDB.from_key(self.method['emission_lines'],
                                                directory_path=emission_line_db_path)
self.neml = None if self.emldb is None else self.emldb.size
```

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

### Instantiate BandheadIndexDB from a keyword

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/bandheadindexdb.html

Use the `from_key` class method to instantiate a BandheadIndexDB using a predefined keyword. This is the recommended way to load default databases.

```python
from mangadap.par.bandheadindexdb import BandheadIndexDB
print(BandheadIndexDB.available_databases())
bhddb = BandheadIndexDB.from_key('BHBASIC')
```

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

### Custom Emission-Line Fitter Implementation Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/development.html

An example of a custom emission-line fitter class, XJMCEmissionLineFitter, inheriting from EmissionLineFit. This code is illustrative and requires further development.

```python
#!/usr/bin/env python3

import time
import warnings
import numpy
import astropy.constants

from mangadap.datacube import MaNGADataCube
from mangadap.proc.reductionassessments import ReductionAssessment
from mangadap.proc.spatiallybinnedspectra import SpatiallyBinnedSpectra
from mangadap.proc.stellarcontinuummodel import StellarContinuumModel
from mangadap.proc.ppxffit import PPXFFit
from mangadap.util.instrument import spectrum_velocity_scale
from mangadap.util.fitsutil import DAPFitsUtil
from mangadap.util.fileio import init_record_array
from mangadap.proc.emissionlinemoments import EmissionLineMoments
from mangadap.proc.spectralfitting import EmissioneLineFit
from mangadap.proc.emissionlinemodel import EmissionLineModelDef, EmissionLineModel
from mangadap.par.emissionlinedb import EmissionLineDB
from mangadap.proc.spectralindices import SpectralIndices
from mangadap.dapfits import construct_maps_file, construct_cube_file

from mangadap.contrib.xjmc import first_second_iteration

#-----------------------------------------------------------------------------

class XJMCEmissionLineFitter(EmissionLineFit):

```

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

### Stacking Function Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.spatiallybinnedspectra.html

Example signature for a stacking function. It takes the data cube, bin ID, and parameters, returning stacked spectral data.

```python
stack_wave, stack_flux, stack_sdev, stack_npix, stack_ivar, stack_sres, stack_covar = stack(cube, id, par=par)
```

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

### Initialize Output Data and Parameters

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/ppxffit.html

Initializes the model flux and parameters for spectral fitting. Sets up binning, pixel statistics, and flags initial errors.

```python
model_flux = numpy.zeros(self.obj_flux.shape, dtype=float)
model_par = self.init_datatable(self.ntpl, self.degree+1, max(self.mdegree,0),
                                        self.moments, self.bitmask.minimum_dtype(),
                                        shape=self.nobj)

model_par['BINID'] = numpy.arange(self.nobj)
model_par['BINID_INDEX'] = numpy.arange(self.nobj)

model_par['BEGPIX'] = self.spectrum_start
model_par['ENDPIX'] = self.spectrum_end
model_par['NPIXTOT'] = self.spectrum_end - self.spectrum_start
```

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

### Radial Binning Starting Radii Calculation

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.spatialbinning.html

Calculates the starting radii for radial binning based on provided parameters. Supports both linear and logarithmic spacing.

```python
rs = self.par['radii'][0]
re = self.par['radii'][1]
nr = int(self.par['radii'][2])
starting_radii = numpy.logspace(numpy.log10(rs), numpy.log10(re), num=nr,
                                endpoint=False) if self.par['log_step'] else
                                numpy.linspace(rs, re, num=nr, endpoint=False)
```

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

### Initialize SpectralPixelMask with Artifact and Emission Line Databases

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/emissionlinemodel.html

Sets up the SpectralPixelMask object, optionally loading artifact and emission line databases based on configuration. Requires artifact_path and ism_line_path to be defined.

```python
self.pixelmask = SpectralPixelMask(artdb=None if self.method['artifacts'] is None else 
                                            ArtifactDB.from_key(self.method['artifacts'],
                                                                directory_path=artifact_path),
                                           emldb=None if self.method['ism_mask'] is None else
                                            EmissionLineDB.from_key(self.method['ism_mask'],
                                                                    directory_path=ism_line_path),
                                           waverange=self.method['waverange'], nsig=2.0)
```

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

### Instantiate from Key

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/spectralfeaturedb.html

Instantiate the object using a keyword to select the database. Searches for '.par' files in the specified or default directory.

```python
@classmethod
def from_key(cls, key, directory_path=None):
        r"""
        Instantiate the object using a keyword.

        Args:
            key (:obj:`str`):
                Keyword selecting the database to use.
            directory_path (:obj:`str`, optional):
                Root path with the database parameter files. If None,
                uses the default set by :func:`available_databases`.
                Note that the file search includes *any* file with a
                ``.par`` extension. The root of the file should be
                case-insensitive.
        """
        databases = cls.available_databases(directory_path=directory_path)
        available_keys = list(databases.keys())
        if key not in available_keys:
```

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

### HDUCLASS Header Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/datamodel.html

Example of the HDUCLASS header block for an extension like EMLINE_GFLUX in MAPS files. It specifies data, inverse variance, and quality mask extensions.

```text
HDUCLASS= 'SDSS    '           / SDSS format class
HDUCLAS1= 'CUBE    '
HDUCLAS2= 'DATA    '
ERRDATA = 'EMLINE_GFLUX_IVAR'  / Associated inv. variance extension
QUALDATA= 'EMLINE_GFLUX_MASK'  / Associated quality extension


```

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

### Example Absorption Line Index Parameter File Entry

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/spectralindices.rst.txt

An example entry in an SDSS-style parameter file for defining absorption line indices, specifying wavelengths and units.

```text
DAPABI  1  CN1        { 4142.125  4177.125 }  { 4080.125  4117.625 }  { 4244.125  4284.125 }  air  mag  0
DAPABI  2  CN2        { 4142.125  4177.125 }  { 4083.875  4096.375 }  { 4244.125  4284.125 }  air  mag  0
```

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

### Instantiate EmissionLineDB from File

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.par.emissionlinedb.html

Shows how to load an emission line database directly from an SDSS-style parameter file.

```APIDOC
## Instantiate EmissionLineDB from File

### Description
This code snippet demonstrates how to instantiate an `EmissionLineDB` object by providing the path to an SDSS-style emission-line database parameter file.

### Method Signature
```python
EmissionLineDB(parfile)
```

### Parameters
* **parfile** (str) - The full path to the emission-line database parameter file (e.g., '/path/to/emission/line/database/myeml.par').

### Returns
An `EmissionLineDB` object loaded from the specified parameter file. The database keyword will be set to the capitalized root name of the `*.par` file.

### Request Example
```python
from mangadap.par.emissionlinedb import EmissionLineDB
emldb = EmissionLineDB('/path/to/emission/line/database/myeml.par')
```
```

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

### Photometry Fix File Format Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/_sources/metadatamodel.rst.txt

Example line from the photometry-fix parameter file, specifying plate, ifudesign, and replacement photometric data (ellipticity, position angle, effective radius).

```c
DAPPHOTCORR   8083 12702 0.265 7.57 28.3
```

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

### Initialize PPXFFit Parameters

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/ppxffit.html

Initializes core parameters for PPXFFit, including template FFT, usage flags, input kinematics, spectral resolution, and wavelength range. This setup is crucial before the main fitting process.

```python
self.tpl_npad = fftpack.next_fast_len(self.npix_tpl)
        self.tpl_rfft = numpy.fft.rfft(self.tpl_flux, self.tpl_npad, axis=1)

        # - Template usage
        self.usetpl = PPXFFit.check_template_usage_flags(self.nobj, self.ntpl, usetpl)
        # - Input kinematics
        self.input_cz, self.guess_kin = PPXFFit.check_input_kinematics(self.nobj, guess_redshift,
                                                                       guess_dispersion)
        # - Spectral resolution
        self.matched_resolution = PPXFFit.check_resolution_match(self.tpl_sres, self.obj_sres,
                                                                 matched_resolution)
        # - Selected wavelength range: always has shape (self.nobj,2)
        # TODO: When is this used?
        self.waverange = PPXFFit.set_wavelength_range(self.nobj, self.obj_wave, waverange=waverange)
```

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

### ParSet Initialization

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.par.parset.html

Demonstrates how to create a ParSet instance with specified parameters, defaults, options, data types, and descriptions.

```APIDOC
## ParSet Initialization

### Description
Create a ParSet instance with parameters, defaults, options, data types, and descriptions.

### Method
`ParSet(pars, defaults=None, options=None, dtypes=None, descr=None)`

### Parameters
- **pars** (list) - Required - List of parameter names.
- **defaults** (list, optional) - Default values for each parameter.
- **options** (list, optional) - Allowed options for each parameter.
- **dtypes** (list, optional) - Data types for each parameter.
- **descr** (list, optional) - Descriptions for each parameter.

### Request Example
```python
from mangadap.par.parset import ParSet
pars = ['test', 'par', 'lst', 'junk']
defaults = ['this', 0, 0.0, None]
options = [['this', 'that'], None, None, None]
dtypes = [str, int, [int, float], None]
descr = ['test parameter description',
         'par parameter description',
         None,
         'this is a rather long description of the junk parameter.  You can include ' \ 
            'rst-style references like pointing back to the ' \ 
            ':class:`~mangadap.par.parset.ParSet` class, for when this description is ' \ 
            'written to an rst table using :func:`~mangadap.par.parset.ParSet.to_rst_table` ' \ 
            'and included in an rst doc synthesized into html using sphinx.']
p = ParSet(pars, defaults=defaults, options=options, dtypes=dtypes, descr=descr)
```
```

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

### mangadap.contrib.xjmc._ppxf_component_setup

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.contrib.xjmc.html

Sets up component, moment, and starting point arrays for a pPXF fitting iteration. It can optionally consolidate all gas components into a single one.

```APIDOC
## mangadap.contrib.xjmc._ppxf_component_setup

### Description
Setup the component, moment, and starting point arrays for a ppxf-fitting iteration. This primarily just sets all the gas components to a single component if requested, restructuring the moment, starting point, and fixed parameter arrays as necessary to reflect this change.

..warning:
```
This function requires that all stellar components have
component numbers that are **less than** any gas components.
However, this **is not checked** by the function.

```

### Parameters
* **component** (numpy.ndarray) – 1D array with the full list of components for all templates. Shape is `(ntpl,)`. The maximum value is `ncomp-1`.
* **moments** (numpy.ndarray) – 1D array with the number of moments for each kinematic component. Shape is `(ncomp,)`.
* **gas_template** (numpy.ndarray) – A boolean array identifying the gas templates. Shape is `(ntpl,)`.
* **start** (numpy.ndarray) – 2D array with the starting kinematics to use for each object spectrum. Shape is `(nobj,sum(moments))`.
* **fixed** (numpy.ndarray) – Boolean array selecting kinematic component that should be fixed during the fit. Each spectrum is fit the same, meaning the shape is the same as the 2nd axis of `start`: `(sum(moments),)`.
* **single_gas_component** (bool, optional) – Flag to force all gas components to have the same kinematics.
* **gas_start** (numpy.ndarray, optional) – Array with the starting kinematics to use for the gas components. Shape must be `(nobj,2)`.

### Returns
Three numpy arrays are returned:
1. The list of down-selected and renumbered, if necessary, kinematic components,
2. the down-selected and reordered, if necessary, number of moments to fit,
3. the down-selected and reordered starting guesses for each component, and
4. the down-selected and reordered fixed moments for each component.

### Return type
tuple

### Raises
**ValueError** – Raised if the provided gas starting kinematics is not correct.
```

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

### get_missing_models

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.emissionlinemodel.html

Get missing models.

```APIDOC
## get_missing_models

### Description
Get missing models.

### Parameters
- **unique_bins** (optional) - Unique bins.
- **debug** (bool, optional) - Debug mode. Defaults to False.
```

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

### Construct DAP Configuration File Example

Source: https://sdss-mangadap.readthedocs.io/en/latest/execution.html

Example command to generate a DAP input configuration file for a specific datacube using the `write_dap_config` script. It specifies the output file name and the input DRPall file.

```bash
write_dap_config 7815 3702 mangadap-7815-3702.ini -a drpall-v3_0_1.fits

```

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

### Instantiate Absorption Index Database from Key

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/absorptionindexdb.html

Load a predefined absorption-line index database using its unique key. This method relies on the default data directory for finding the parameter files.

```python
from mangadap.par.absorptionindexdb import AbsorptionIndexDB
absdb = AbsorptionIndexDB.from_key('LICKINDX')
```

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

### Example Generated DAP Script

Source: https://sdss-mangadap.readthedocs.io/en/latest/execution.html

This is an example of a script file generated by `rundap`. It outlines the steps involved in processing a single plate-ifu, including touching start/done files and executing the main DAP analysis and QA plotting.

```bash
#!/bin/bash -l

#PBS -l nodes=1:ppn=8
#PBS -l walltime=240:00:00
#PBS -N mangadap-7495-12704
#PBS -j oe
#PBS -o /path/for/dap/output/log/7495/12704/mangadap-7495-12704.out
#PBS -e /path/for/dap/output/log/7495/12704/mangadap-7495-12704.err


# Set up the environment
source /path/to/your/dap/environment/setup.sh

# Touch the start file
touch /path/for/dap/output/log/7495/12704/mangadap-7495-12704.started

# Execute the DAP analysis
manga_dap --platelist 7495 --ifudesignlist 12704 --redux_path /path/with/drp/output/drpver --analysis_path /path/for/dap/output/drpver/dapver -vv

# Execute QA plotting scripts (example)
# python /path/to/dap/qa/scripts/plot_cube.py --input /path/for/dap/output/7495/12704/manga-7495-12704-MAPS.fits --output /path/for/dap/output/log/7495/12704/qa_plots/

# Touch the done file
touch /path/for/dap/output/log/7495/12704/mangadap-7495-12704.done

```

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

### ElricFittingWindow Initialization

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/elric.html

Initializes a utility class for managing emission-line fitting windows. Allows specification of lines, profile forms, bounds, and tied parameters.

```python
class ElricFittingWindow:
    r"""

    A utility class for the fitting windows used by Elric

    The class can be instantiated as fully None.

    Args:
        nlines (int): (**Optional**) The number of lines to be fit
            simultaneously.
        db_indx (`numpy.ndarray`_): (**Optional**) An array with the
            database index (0-based) of each line to be fit.
        line_index (`numpy.ndarray`_): (**Optional**) An array with the
            index numbers, read from the database, of each line to be
            fit.
        restwave (`numpy.ndarray`_): (**Optional**) An array with the rest
            wavelengths of each line to be fit.
        profile_set (`numpy.ndarray`_): (**Optional**) An array with the
            profile objects that define the functional form of each
            line.
        fixed_par (`numpy.ndarray`_): (**Optional**) An array with the
            fixed parameters for *all* parameters in the model to be
            fit.
        bounds (`numpy.ndarray`_): (**Optional**) A two-column array with
            the lower (first column) and upper (second column) bounds
            for the fit parameters.
        log_bounds (`numpy.ndarray`_): (**Optional**) The range of the
            boundary should be considered as logarithmic when testing if
            a parameter is near its boundary.
        output_model (bool): (**Optional**) Include the best-fitting
            model in the composite emission-line model for each
            spectrum.  This is only flagged as true if ALL the emission
            lines in the fitting window are to be included according to
            the emission-line database.
        tied_pairs (`numpy.ndarray`_): (**Optional**) The series of
            tied profiles (:class:`TiedLineProfile` objects) that are
            used to tie parameters of the model.
        tied_funcs (`numpy.ndarray`_): (**Optional**) The member functions
            of the :class:`TiedLineProfile` objects that should be
            called *sequentially* to tie model parameters.
    """
    def __init__(self, nlines=None, db_indx=None, line_index=None, restwave=None, profile_set=None,
                 fixed_par=None, bounds=None, log_bounds=None, output_model=None, tied_pairs=None,
                 tied_funcs=None):

        self.nlines = nlines
        self.db_indx = db_indx
```

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

### Get Channel Names for Emission Moments

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/emissionmomentsdb.html

Returns channel names formatted as 'name-restwave' for each emission line. Can return as a dictionary mapping names to indices or a list of names. Use this to get a mapping or list of available channels.

```python
def channel_names(self, dicttype=True):
        """
        Return a dictionary with the channel names as the dictionary
        key and the channel number as the dictionary value. If
        ``dicttype`` is False, a list is returned with just the
        string keys.
        """
        channels = [ '{0}-{1}'.format(self.data['name'][i], int(self.data['restwave'][i])) 
                            for i in range(self.size) ]
        return { n:i for i,n in enumerate(channels) } if dicttype else channels
```

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

### Instantiate Absorption Index Database from Parameter File

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/absorptionindexdb.html

Create an absorption-line index database instance by providing the path to a custom SDSS-style parameter file. The database key will be derived from the filename.

```python
from mangadap.par.absorptionindexdb import AbsorptionIndexDB
absdb = AbsorptionIndexDB('/path/to/absorption/index/database/myabs.par')
```

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

### Initialize SpectralFeatureDB

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/spectralfeaturedb.html

Instantiate the SpectralFeatureDB with a given parameter file. Raises FileNotFoundError if the file does not exist.

```python
def __init__(self, parfile):
        # TODO: The approach here (read using yanny, set to par
        # individually, then covert back to record array using
        # ParDatabase) is stupid...
        _parfile = Path(parfile).resolve()
        if not _parfile.exists():
            raise FileNotFoundError(f'{_parfile} not found!')

        self.key = util.get_database_key(str(_parfile))
        self.file = str(_parfile)
        self.size = None

        # _parse_yanny() has to set `size` for each subclass.
        ParDatabase.__init__(self, self._parse_yanny())
        self._validate()
```

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

### Calculate Bin Starting Radii and Step

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/proc/spatialbinning.html

Determines the starting radii and step size for radial bins, supporting both logarithmic and linear spacing. It also handles cases where radii need to be set based on input data or default values.

```python
def _r_start_step(self, r):
        """
        Bin starting radii are::
            
            rs = self.par['radii'][0]
            re = self.par['radii'][1]
            nr = int(self.par['radii'][2])
            starting_radii = numpy.logspace(numpy.log10(rs), numpy.log10(re), num=nr,
                                            endpoint=False) if self.par['log_step'] else \
                             numpy.linspace(rs, re, num=nr, endpoint=False)

        For ending radii, just swap ``rs`` and ``re`` above.

        Args:
            r (`numpy.ndarray`_):
                Fiducial radius of each spectrum.
        """
        # Set minimum radius, if necessary
        if self.par['radii'][0] < 0:
            ndec = int(numpy.floor(numpy.absolute(numpy.log10(0.5/self.par['radius_scale']))))
            ndec = 2 if ndec < 2 else ndec
            self.par['radii'][0] = numpy.around(0.5/self.par['radius_scale'], decimals=ndec) \
                                        if self.par['log_step'] else 0.0
            self.to_center = True

        # Set maximum radius, if necessary
        if self.par['radii'][1] < 0:
            self.par['radii'][1] = numpy.around(numpy.amax(r)+0.1, decimals=2)

        # Get the logarithmically stepped values
        if self.par['log_step']:
            self.rs = numpy.log10(self.par['radii'][0])
            self.dr = (numpy.log10(self.par['radii'][1]) - self.rs)/self.par['radii'][2]
            return

        # Get the linearly stepped values
        self.rs = self.par['radii'][0]
        self.dr = (self.par['radii'][1] - self.rs)/self.par['radii'][2]

```

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

### Construct Emission-Line Templates

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.emissionlinetemplates.html

Demonstrates the basic construction of emission-line templates. Requires a wavelength vector, instrumental resolution, and an emission line database.

```python
from mangadap.proc.emissionlinetemplates import EmissionLineTemplate
from mangadap.par.emissionlinedb import EmissionLineDB
import numpy as np

# Wavelength vector (e.g., in Angstroms)
wave = np.linspace(3500., 10000., 6501)

# Instrumental resolution (e.g., R = lambda/FWHM)
# For simplicity, assume constant resolution
# For variable resolution, this should be a vector of the same size as wave
inst_res = 2000.

# Emission line database
eline_db = EmissionLineDB.default()

# Construct the templates
elt = EmissionLineTemplate(wave, inst_res, eline_db=eline_db)
```

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

### metakeys

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/datacube/datacube.html

Get a list of the keys in the datacube metadata.

```APIDOC
## metakeys

### Description
Get a list of the keys in the datacube metadata.

### Returns
list: A list of metadata keys.
```

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

### Instantiate BandheadIndexDB from a parameter file

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/bandheadindexdb.html

Instantiate a BandheadIndexDB directly from an SDSS-style parameter file. The database keyword will be derived from the filename.

```python
from mangadap.par.bandheadindexdb import BandheadIndexDB
bhddb = BandheadIndexDB('/path/to/bandhead/index/database/mybhd.par')
```

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

### DataCube.nspec

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/datacube/datacube.html

Property to get the number of spectra in the datacube.

```APIDOC
## DataCube.nspec

### Description
Number of spectra in the datacube.
```

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

### pseudocontinuum

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.proc.bandpassfilter.html

Get the pseudocontinuua in a set of passbands for a single vector (y).

```APIDOC
## pseudocontinuum

### Description
Get the pseudocontinuua in a set of passbands for a single vector (y).

### Parameters
- **_x_** (array-like) - Input data array.
- **_y_** (array-like) - Input data array.
- **_passband** (array-like, optional) - Passband definition.
- **_err** (array-like, optional) - Error array.
- **_log** (bool, optional) - Whether the data is in log space.
- **_weighted_center** (bool, optional) - Whether to use the weighted center.

### Returns
- **tuple**: Five arrays or floats: (1) The center of each passband, (2) the mean continuum level, (3) the propagated error in the continuum level (will be None if no errors are provided), (4) flag that part of the passband was masked, (5) flag that the passband was fully masked or empty.
```

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

### Instantiate EmissionLineDB from Key

Source: https://sdss-mangadap.readthedocs.io/en/latest/api/mangadap.par.emissionlinedb.html

Create an EmissionLineDB object using a predefined database key. This method is convenient for loading standard emission-line configurations.

```python
from mangadap.par.emissionlinedb import EmissionLineDB
emldb = EmissionLineDB.from_key('ELPMPL9')
```

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

### Get Reddening Vector

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/util/extinction.html

Returns the inverse of the reddening correction vector.

```python
def _redden_vec(self):
        return numpy.ma.power(self.redcorr, -1)
```

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

### Get Dereddening Vector

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/util/extinction.html

Returns the computed reddening correction vector.

```python
def _deredden_vec(self):
        return self.redcorr
```

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

### Instantiate EmissionMomentsDB from Parameter File

Source: https://sdss-mangadap.readthedocs.io/en/latest/_modules/mangadap/par/emissionmomentsdb.html

Create an EmissionMomentsDB instance by providing the path to a custom SDSS-style parameter file. The database keyword is derived from the filename.

```python
from mangadap.par.emissionmomentsdb import EmissionMomentsDB
elmom = EmissionMomentsDB('/path/to/emission/moments/database/myelm.par')
```
Tokens:
Raw