### Install Local Python-FSPS Clone with Pip Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Recommends installing a local Python-FSPS clone using `pip install .` from the repository's root directory. Although 'development' or 'editable' builds are no longer supported, subsequent `pip install` commands will reuse cached builds. ```bash python -m pip install . ``` -------------------------------- ### Install and Run Python-FSPS Unit Tests with Nox Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Instructions for installing `nox`, a test automation tool, and then executing the Python-FSPS unit tests using `nox`. This provides a convenient way to run the project's test suite. ```bash python -m pip install nox python -m nox ``` -------------------------------- ### Install Stable Python-FSPS via Pip Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst This snippet demonstrates how to install the stable version of Python-FSPS directly from PyPI using the `pip` package manager. This is the recommended method for most users. ```bash python -m pip install fsps ``` -------------------------------- ### Clone and Install Python-FSPS Development Version Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Steps to obtain and install the latest development version of Python-FSPS directly from its GitHub repository. The `--recursive` flag ensures that the embedded FSPS submodule is also cloned, eliminating the need for a separate FSPS installation. ```bash git clone --recursive https://github.com/dfm/python-fsps.git cd python-fsps python -m pip install . ``` -------------------------------- ### Install and Run Python-FSPS Unit Tests with Pytest Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Steps to install `pytest` along with the necessary test dependencies and directly run the Python-FSPS unit tests. The `-n` flag allows specifying the number of parallel processes, which can speed up slow tests but requires careful memory management. ```bash python -m pip install ".[test]" python -m pytest -n 2 -v tests/tests.py ``` -------------------------------- ### Initialize and Update FSPS Submodule Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Commands to manually initialize and update the FSPS submodule within the Python-FSPS repository. This is necessary if the `--recursive` flag was omitted during the initial `git clone` of the Python-FSPS project. ```bash git submodule init git submodule update ``` -------------------------------- ### Reinstall Python-FSPS with Custom Stellar Libraries Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Shows how to uninstall Python-FSPS and then reinstall it with specific compiler flags (`FFLAGS`) to switch between different stellar isochrone and spectral libraries (e.g., Padova and BaSeL). The `--no-binary fsps` flag is essential to force a build from source, allowing the flags to take effect. ```bash pip uninstall fsps FFLAGS="-DMIST=0 -DPADOVA=1 -DMILES=0 -DBASEL=1" python -m pip install fsps --no-binary fsps ``` -------------------------------- ### Clone FSPS Repository and Set SPS_HOME Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Instructions to clone the FSPS project, which provides necessary data files for Python-FSPS, and set the `SPS_HOME` environment variable. This variable is crucial for Python-FSPS to locate its dependencies and will cause import failures if incorrectly set. Python-FSPS requires FSPS v3.2. ```bash export SPS_HOME="/path/where/you/want/to/download/fsps" git clone https://github.com/cconroy20/fsps.git $SPS_HOME ``` -------------------------------- ### Set SPS_HOME for Local Python-FSPS Clone Source: https://github.com/dfm/python-fsps/blob/main/docs/installation.rst Guidance on setting the `SPS_HOME` environment variable when Python-FSPS is installed from a local clone that includes FSPS as a submodule. This ensures Python-FSPS correctly locates its Fortran dependencies. ```bash export SPS_HOME=$(pwd)/src/fsps/libfsps ``` -------------------------------- ### Configure and Install Python FSPS Module Source: https://github.com/dfm/python-fsps/blob/main/src/fsps/CMakeLists.txt This CMake block defines the '_fsps' Python module, specifying all its source components including the main Fortran file, the explicitly listed FSPS Fortran sources, and the f2py generated wrappers. It links the module against NumPy, includes necessary f2py headers, and configures the installation path for the built module. ```CMake python_add_library( _fsps MODULE "${CMAKE_CURRENT_SOURCE_DIR}/fsps.f90" ${FSPS_SOURCES} ${F2PY_SOURCES} "${F2PY_INCLUDE_DIR}/fortranobject.c" WITH_SOABI) target_link_libraries(_fsps PUBLIC Python::NumPy) target_include_directories(_fsps PUBLIC "${F2PY_INCLUDE_DIR}") install(TARGETS _fsps DESTINATION ${SKBUILD_PROJECT_NAME}) ``` -------------------------------- ### Example Usage of FSPS Filters in Python Source: https://github.com/dfm/python-fsps/blob/main/docs/filters_api.rst This example demonstrates how to find available SDSS filters, retrieve a specific filter instance (sdss_g), and access its properties like Solar absolute magnitude (msun_ab) and effective wavelength (lambda_eff). ```python import fsps fsps.find_filter('sdss') # Expected output: ['sdss_u', 'sdss_g', 'sdss_i', 'sdss_r', 'sdss_z'] g = fsps.get_filter('sdss_g') g.msun_ab # Expected output: 5.12 g.lambda_eff # Expected output: 4702.5 ``` -------------------------------- ### Adjust Nebular Emission Parameters and Get Spectrum (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Explains how to modify parameters related to nebular emission, such as stellar metallicity (`logzsol`), gas phase metallicity (`gas_logz`), and gas ionization parameter (`gas_logu`). It then shows how to retrieve the combined stellar and nebular spectrum at a specific age. ```python sp.params['logzsol'] = -1.0 sp.params['gas_logz'] = -1.0 sp.params['gas_logu'] = -2.5 wave, spec = sp.get_spectrum(tage=0.001) ``` -------------------------------- ### Get Magnitudes for FSPS Filters in Python Source: https://github.com/dfm/python-fsps/blob/main/docs/filters.rst This snippet demonstrates how to use the `fsps` Python library to calculate magnitudes for a stellar population across specified FSPS filter bandpasses. Filter names are case-insensitive and correspond to the names listed in the FSPS filter table. ```Python import fsps sp = fsps.StellarPopulation() sp.get_mags(bands=['WFC_ACS_F606W', 'WFC_ACS_F814W']) ``` -------------------------------- ### Initialize StellarPopulation with Dust and Check Libraries (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Initializes a `StellarPopulation` object with specific parameters, including solar metallicity and a Calzetti et al. (2000) extinction curve. It then demonstrates how to check the underlying stellar isochrone and spectral libraries being used by the FSPS instance. ```python import fsps sp = fsps.StellarPopulation(compute_vega_mags=False, zcontinuous=1, sfh=0, logzsol=0.0, dust_type=2, dust2=0.2) sp.libraries ``` -------------------------------- ### Initialize StellarPopulation with Nebular Emission (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Demonstrates how to initialize a `StellarPopulation` object with the `add_neb_emission` flag set to enable the inclusion of nebular emission in the model calculations. ```python sp = fsps.StellarPopulation(zcontinuous=1, add_neb_emission=1) ``` -------------------------------- ### Retrieve Spectrum and Stellar Mass (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Shows how to obtain the full spectrum (in units of L_sun/Hz) for a stellar population at a specified age using `get_spectrum`. Additionally, it demonstrates how to access the total stellar mass formed and the surviving stellar mass (both in M_sun) at that age. ```python wave, spec = sp.get_spectrum(tage=13.7) sp.formed_mass sp.stellar_mass ``` -------------------------------- ### Configure CMake Build Environment for Python-FSPS Source: https://github.com/dfm/python-fsps/blob/main/CMakeLists.txt This CMake script sets up the build environment for the `python-fsps` project. It specifies the minimum required CMake version, defines the project name and supported languages (C, Fortran), and locates necessary Python components including the interpreter, development modules, and NumPy. It also executes a Python script to find the f2py include directory, essential for Fortran-Python interoperability, and adds a subdirectory for source compilation. ```CMake cmake_minimum_required(VERSION 3.17.2...3.26) project(${SKBUILD_PROJECT_NAME} LANGUAGES C Fortran) find_package( Python COMPONENTS Interpreter Development.Module NumPy REQUIRED) # Find the f2py headers execute_process( COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/f2py_include.py" OUTPUT_VARIABLE F2PY_INCLUDE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE) add_subdirectory(src/fsps) ``` -------------------------------- ### fsps.StellarPopulation Class API Reference Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Reference for the `fsps.StellarPopulation` class, the primary API for stellar population modeling in python-FSPS. It allows initialization with various parameters, modification of properties, and retrieval of magnitudes, spectra, and stellar mass information. This class is designed for single-instance usage within a program. ```APIDOC class fsps.StellarPopulation: __init__( compute_vega_mags: bool = False, zcontinuous: int = 1, sfh: int = 0, logzsol: float = 0.0, dust_type: int = 2, dust2: float = 0.2, add_neb_emission: int = 0 ) Initializes a StellarPopulation object with specified parameters. Parameters: compute_vega_mags (bool): If True, compute Vega magnitudes. zcontinuous (int): Flag for continuous metallicity. 1 for continuous. sfh (int): Star formation history flag. 0 for SSP. logzsol (float): Logarithm of Z/Z_sun. dust_type (int): Type of dust attenuation curve. 2 for Calzetti et al. (2000). dust2 (float): Dust optical depth parameter. add_neb_emission (int): Flag to include nebular emission. 1 to enable. properties: libraries: tuple Returns the tuple of isochrone and spectral libraries used (e.g., ('mist', 'miles')). params: dict A dictionary-like object to access and modify stellar population parameters (e.g., 'logzsol', 'gas_logz', 'gas_logu'). formed_mass: float Total stellar mass formed by the current age (in M_sun). stellar_mass: float Surviving stellar mass at the current age (in M_sun). emline_wavelengths: array Array of emission line wavelengths (available when nebular emission is enabled). emline_luminosity: array Array of emission line luminosities (available when nebular emission is enabled). methods: get_mags(tage: float, bands: list) -> array Calculates and returns AB magnitudes for specified bands at a given age. Parameters: tage (float): Age of the stellar population in Gyr. bands (list): List of filter names (e.g., ['sdss_u', 'sdss_g']). Returns: array: Array of AB magnitudes. get_spectrum(tage: float) -> tuple[array, array] Retrieves the spectrum (wavelengths and flux) for the stellar population at a given age. The flux is in units of L_sun/Hz. Parameters: tage (float): Age of the stellar population in Gyr. Returns: tuple[array, array]: A tuple containing (wavelengths, spectrum_flux). ``` -------------------------------- ### Jinja2 Template for Sphinx Related Topics Navigation Source: https://github.com/dfm/python-fsps/blob/main/docs/_themes/dfm/relations.html This template dynamically generates navigation links for Sphinx documentation. It iterates through parent pages, and conditionally displays links for previous and next chapters, along with a link to the documentation overview. It uses Jinja2 syntax with Sphinx-specific functions like `pathto` and `_` for internationalization. ```Jinja2 ### Related Topics * [Documentation overview]({{ pathto(master_doc) }}) {%- for parent in parents %}* [{{ parent.title }}]({{ parent.link|e }}) {%- endfor %} {%- if prev %}* Previous: [{{ prev.title }}]({{ prev.link|e }} "{{ _('previous chapter') }}") {%- endif %} {%- if next %}* Next: [{{ next.title }}]({{ next.link|e }} "{{ _('next chapter') }}") {%- endif %} {%- for parent in parents %} {%- endfor %} ``` -------------------------------- ### Access Emission Line Wavelengths and Luminosities (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Shows how to directly access the calculated emission line wavelengths and their corresponding luminosities from the `StellarPopulation` object, useful for analyzing the nebular component of the spectrum. ```python sp.emline_wavelengths sp.emline_luminosity ``` -------------------------------- ### Generate Python f2py Wrappers for FSPS Source: https://github.com/dfm/python-fsps/blob/main/src/fsps/CMakeLists.txt This CMake command defines the process for generating C and Fortran wrapper files using numpy.f2py. It specifies the input Fortran file (fsps.f90), the output module name (_fsps), and the build directory, ensuring that the necessary interfaces for Python-Fortran interaction are created. ```CMake set(F2PY_SOURCES "${CMAKE_CURRENT_BINARY_DIR}/_fspsmodule.c" "${CMAKE_CURRENT_BINARY_DIR}/_fsps-f2pywrappers2.f90" ) add_custom_command( OUTPUT ${F2PY_SOURCES} DEPENDS fsps.f90 VERBATIM COMMAND "${Python_EXECUTABLE}" -m numpy.f2py "${CMAKE_CURRENT_SOURCE_DIR}/fsps.f90" -m _fsps --lower --build-dir "${CMAKE_CURRENT_BINARY_DIR}") ``` -------------------------------- ### Retrieve AB Magnitudes in SDSS Bands (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Demonstrates how to use `fsps.find_filter` to locate specific photometric bands (e.g., SDSS) and then retrieve the AB magnitudes for a simple stellar population (SSP) at a given age (e.g., 13.7 Gyr) using the `get_mags` method. ```python sdss_bands = fsps.find_filter('sdss') print(sdss_bands) sp.get_mags(tage=13.7, bands=sdss_bands) ``` -------------------------------- ### Configure dfm Sphinx Theme in Python Source: https://github.com/dfm/python-fsps/blob/main/docs/_themes/README.rst This code snippet demonstrates how to configure the 'dfm' Sphinx theme in a Python `conf.py` file. It appends the `_themes` directory to the system path and sets the `html_theme_path` and `html_theme` variables to enable the custom theme. ```Python sys.path.append(os.path.abspath('_themes')) html_theme_path = ['_themes'] html_theme = 'dfm' ``` -------------------------------- ### Update Stellar Population Parameter and Recalculate Magnitudes (Python) Source: https://github.com/dfm/python-fsps/blob/main/docs/stellarpop_api.rst Illustrates how to dynamically change a parameter of an existing `StellarPopulation` instance, such as `logzsol` (metallicity), and then re-calculate the magnitudes to observe the effect of the parameter change. ```python sp.params['logzsol'] = -1 sp.get_mags(tage=13.7, bands=sdss_bands) ``` -------------------------------- ### Verify FSPS Submodule Existence Source: https://github.com/dfm/python-fsps/blob/main/src/fsps/CMakeLists.txt This CMake snippet checks for the presence of a critical Fortran source file within the 'libfsps' submodule. If the file is not found, it indicates that the submodule has not been initialized and instructs the user to run 'git submodule update --init' to resolve the issue, preventing further build errors. ```CMake if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sps_vars.f90") message(FATAL_ERROR "The source code in the FSPS submodule was not found." "Please run 'git submodule update --init' to initialize the submodule.") endif() ``` -------------------------------- ### FSPS Filter API Reference Source: https://github.com/dfm/python-fsps/blob/main/docs/filters_api.rst This section provides a reference to the core API functions and classes for working with filters in Python-FSPS, including functions to find, list, and retrieve filters, and the Filter class itself. ```APIDOC fsps.find_filter Description: Function to find available filters. fsps.list_filters Description: Function to list all available filters. fsps.get_filter Description: Function to retrieve a specific filter instance. fsps.filters.Filter Description: Class representing a filter, providing properties like transmission curve, Solar absolute magnitude, and effective wavelength. Inherited Members: All inherited members are exposed. ``` -------------------------------- ### Define Explicit FSPS Fortran Source Files Source: https://github.com/dfm/python-fsps/blob/main/src/fsps/CMakeLists.txt This section explicitly lists all individual Fortran source files from the 'libfsps/src' directory that constitute the core FSPS library. This approach is used instead of a glob pattern to prevent inadvertently including executable files or other unwanted artifacts present in the source directory, ensuring a clean build. ```CMake set( FSPS_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sps_vars.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sps_utils.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_agb_dust.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_bs.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_dust.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_nebular.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_remnants.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/add_xrb.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/agn_dust.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/attn_curve.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/compsp.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/csp_gen.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/funcint.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/get_lumdist.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/get_tuniv.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/getindx.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/getmags.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/getspec.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/igm_absorb.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/imf.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/imf_weight.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/intsfwght.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/linterp.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/linterparr.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/locate.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/mod_gb.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/mod_hb.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/pz_convol.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sbf.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/setup_tabular_sfh.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sfh_weight.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sfhinfo.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sfhlimit.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sfhstat.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/smoothspec.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/spec_bin.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/sps_setup.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/ssp_gen.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/tsum.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/vacairconv.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/write_isochrone.f90" "${CMAKE_CURRENT_SOURCE_DIR}/libfsps/src/ztinterp.f90" ) ``` -------------------------------- ### Available Photometric Filters Data Table Source: https://github.com/dfm/python-fsps/blob/main/docs/filter_table.rst This table lists the photometric filters supported by the `python-fsps` library, including their internal identifiers, numerical properties (likely related to effective wavelength, bandwidth, etc.), and a descriptive name with the instrument source. The URLs provide further details on the filter throughput curves. ```APIDOC 40 wfc3_uvis_f438w 5.49 5.34 4326.5 HST WFC3 UVIS F438W (``_) Chip #1 41 wfc3_uvis_f475w 5.19 5.08 4773.7 HST WFC3 UVIS F475W (``_) Chip #1 42 wfc3_uvis_f555w 4.89 4.86 5308.2 HST WFC3 UVIS F555W (``_) Chip #1 43 wfc3_uvis_f606w 4.65 4.73 5887.4 HST WFC3 UVIS F606W (``_) Chip #1 44 wfc3_uvis_f775w 4.15 4.53 7648.5 HST WFC3 UVIS F775W (``_) Chip #1 45 wfc3_uvis_f814w 4.11 4.52 8029.5 HST WFC3 UVIS F814W (``_) Chip #1 46 wfc3_uvis_f850lp 4.00 4.52 9168.9 HST WFC3 UVIS F850LP (``_) Chip #1 47 wfc3_ir_f098m 3.96 4.51 9862.9 HST WFC3 IR F098M (``_) 48 wfc3_ir_f105w 3.89 4.53 10550.7 HST WFC3 IR F105W (``_) 49 wfc3_ir_f110w 3.79 4.54 11534.4 HST WFC3 IR F110W (``_) 50 wfc3_ir_f125w 3.67 4.56 12486.1 HST WFC3 IR F125W (``_) 51 wfc3_ir_f140w 3.52 4.60 13923.9 HST WFC3 IR F140W (``_) 52 wfc3_ir_f160w 3.40 4.65 15370.8 HST WFC3 IR F160W (``_) 53 irac_1 3.21 5.99 35569.7 Spitzer IRAC Channel 1 (3.6um) 54 irac_2 3.16 6.41 45020.4 Spitzer IRAC Channel 2 (4.5um) 55 irac_3 3.12 6.87 57454.1 Spitzer IRAC Channel 3 (5.8um) 56 irac_4 3.09 7.47 79162.1 Spitzer IRAC Channel 4 (8.0um) 57 isaac_ks 3.30 5.13 21622.1 ISAAC Ks 58 fors_v 4.78 4.79 5536.1 FORS V 59 fors_r 4.41 4.60 6564.6 FORS R 60 nicmos_f110w 3.82 4.54 11248.6 HST NICMOS F110W 61 nicmos_f160w 3.37 4.68 16060.4 HST NICMOS F160W 62 galex_fuv 14.91 17.24 1535.1 GALEX FUV 63 galex_nuv 8.41 10.15 2300.7 GALEX NUV 64 des_g 5.17 5.08 4800.9 DES g (from Huan Lin, for DES camera) 65 des_r 4.46 4.62 6362.6 DES r (from Huan Lin, for DES camera) 66 des_i 4.13 4.52 7750.1 DES i (from Huan Lin, for DES camera) 67 des_z 4.00 4.52 9153.7 DES z (from Huan Lin, for DES camera) 68 des_y 3.96 4.51 9907.8 DES Y (from Huan Lin, for DES camera) 69 wfcam_z 4.01 4.52 8826.3 WFCAM (UKIRT) Z (from Hewett et al. 2006, via A. Smith) 70 wfcam_y 3.91 4.51 10314.1 WFCAM (UKIRT) Y (from Hewett et al. 2006, via A. Smith) 71 wfcam_j 3.65 4.56 12500.9 WFCAM (UKIRT) J (from Hewett et al. 2006, via A. Smith) 72 wfcam_h 3.35 4.70 16359.1 WFCAM (UKIRT) H (from Hewett et al. 2006, via A. Smith) 73 wfcam_k 3.30 5.17 22084.0 WFCAM (UKIRT) K (from Hewett et al. 2006, via A. Smith) 74 steidel_un 5.44 6.34 3602.5 Steidel Un (via A. Shapley; see Steidel et al. 2003) 75 steidel_g 5.19 5.08 4753.2 Steidel G (via A. Shapley; see Steidel et al. 2003) 76 steidel_rs 4.33 4.58 6781.4 Steidel Rs (via A. Shapley; see Steidel et al. 2003) 77 steidel_i 4.09 4.52 7985.7 Steidel I (via A. Shapley; see Steidel et al. 2003) 78 megacam_u 5.68 6.03 3802.9 CFHT MegaCam u* (``_, Dec 2010) 79 megacam_g 5.14 5.05 4844.4 CFHT MegaCam g' (``_, Dec 2010) 80 megacam_r 4.48 4.63 6247.7 CFHT MegaCam r' (``_, Dec 2010) 81 megacam_i 4.17 4.53 7538.7 CFHT MegaCam i' (``_, Dec 2010) 82 megacam_z 4.00 4.51 8860.0 CFHT MegaCam z' (``_, Dec 2010) 83 wise_w1 3.22 5.89 33682.1 WISE W1, 3.4um (``_) ``` -------------------------------- ### Photometric Filters Supported by python-fsps Source: https://github.com/dfm/python-fsps/blob/main/docs/filter_table.rst This table provides a detailed list of photometric filters available for use within the python-fsps library. Each entry includes the filter's unique identifier, its common name, the zero-point magnitudes in both Vega and AB systems, the effective wavelength, and a descriptive note about its origin or associated telescope/survey. ```APIDOC === ================ ========== ======== =============== ======================================================================================== ID Name M_sun Vega M_sun AB lambda_eff (Å) Description === ================ ========== ======== =============== ======================================================================================== 1 v 4.81 4.81 5477.6 Johnson V (from Bessell 1990 via M. Blanton) - this defines the Vega system 2 u 5.55 6.35 3584.8 Johnson U (from Bessell 1990 via M. Blanton) 3 b 5.46 5.35 4370.9 Johnson B (from Bessell 1990 via M. Blanton) 4 buser_b2 5.41 5.30 4433.5 Buser B2 (from BC03) 5 cousins_r 4.41 4.60 6576.9 Cousins R (from Bessell 1990 via M. Blanton) 6 cousins_i 4.10 4.52 7891.2 Cousins I (from Bessell 1990 via M. Blanton) 7 cfht_b 5.41 5.28 4418.6 CFHT B-band (from Blanton's kcorrect) 8 cfht_r 4.37 4.59 6616.0 CFHT R-band (from Blanton's kcorrect) 9 cfht_i 4.08 4.52 8166.0 CFHT I-band (from Blanton's kcorrect) 10 2mass_j 3.67 4.56 12387.7 2MASS J filter (total response w/atm) 11 2mass_h 3.34 4.70 16488.9 2MASS H filter (total response w/atm) 12 2mass_ks 3.30 5.14 21635.6 2MASS Ks filter (total response w/atm) 13 sdss_u 5.47 6.39 3556.5 SDSS Camera u Response Function, airmass = 1.3 (June 2001) 14 sdss_g 5.23 5.12 4702.5 SDSS Camera g Response Function, airmass = 1.3 (June 2001) 15 sdss_r 4.50 4.64 6175.6 SDSS Camera r Response Function, airmass = 1.3 (June 2001) 16 sdss_i 4.18 4.53 7489.9 SDSS Camera i Response Function, airmass = 1.3 (June 2001) 17 sdss_z 4.00 4.51 8946.8 SDSS Camera z Response Function, airmass = 1.3 (June 2001) 18 wfpc2_f255w 7.44 9.06 2601.0 HST WFPC2 F255W (``_) 19 wfpc2_f300w 6.05 7.40 2994.3 HST WFPC2 F300W (``_) 20 wfpc2_f336w 5.46 6.64 3359.2 HST WFPC2 F336W (``_) 21 wfpc2_f439w 5.51 5.36 4311.7 HST WFPC2 F439W (``_) 22 wfpc2_f450w 5.31 5.22 4555.6 HST WFPC2 F450W (``_) 23 wfpc2_f555w 4.83 4.82 5438.9 HST WFPC2 F555W (``_) 24 wfpc2_f606w 4.61 4.70 5996.8 HST WFPC2 F606W (``_) 25 wfpc2_f814w 4.11 4.52 8012.3 HST WFPC2 F814W (``_) 26 wfpc2_f850lp 4.00 4.52 9129.0 HST WFPC2 F850LP (``_) 27 wfc_acs_f435w 5.48 5.38 4318.1 HST ACS F435W (``_) 28 wfc_acs_f475w 5.21 5.10 4744.3 HST ACS F475W (``_) 29 wfc_acs_f555w 4.85 4.84 5359.5 HST ACS F555W (``_) 30 wfc_acs_f606w 4.64 4.72 5912.4 HST ACS F606W (``_) 31 wfc_acs_f625w 4.47 4.63 6310.5 HST ACS F625W (``_) 32 wfc_acs_f775w 4.14 4.53 7693.3 HST ACS F775W (``_) 33 wfc_acs_f814w 4.10 4.52 8059.6 HST ACS F814W (``_) 34 wfc_acs_f850lp 4.00 4.51 9054.5 HST ACS F850LP (``_) 35 wfc3_uvis_f218w 8.95 10.71 2226.5 HST WFC3 UVIS F218W (``_) Chip #1 36 wfc3_uvis_f225w 8.37 10.10 2372.5 HST WFC3 UVIS F225W (``_) Chip #1 37 wfc3_uvis_f275w 6.99 8.54 2710.1 HST WFC3 UVIS F275W (``_) Chip #1 38 wfc3_uvis_f336w 5.47 6.65 3355.1 HST WFC3 UVIS F336W (``_) Chip #1 39 wfc3_uvis_f390w 5.64 5.85 3924.4 HST WFC3 UVIS F390W (``_) Chip #1 ``` -------------------------------- ### Sphinx Sidebar Local Table of Contents Jinja2 Template Source: https://github.com/dfm/python-fsps/blob/main/docs/_themes/dfm/localtoc.html This Jinja2 template defines the structure for a local table of contents in a Sphinx sidebar. It checks if 'display_toc' is true, then renders an H3 heading 'Contents' linked to the master document, and inserts the table of contents using the 'toc' variable. The initial comment block provides metadata about the file. ```Jinja2 {# basic/localtoc.html ~~~~~~~~~~~~~~~~~~~ Sphinx sidebar template: local table of contents. :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS. :license: BSD, see LICENSE for details. #} {%- if display\\_toc %}\n\n### [{{ \\_('Contents') }}]({{ pathto\\(master_doc\\) }})\n\n{{ toc }} {%- endif %} ```