add specific accretion rate plot

_readthedocs

_build

.coverage

docs/autoapi

# backup

*.bak*

fig/plambda_qu_sf_ctn_ctk.pdf: python/plot_plambda_qu_sf_ctn_ctk.py

	python3 $< $@

fig/plambda_qu_sf_ctn_ctk_20251006.pdf: src/scripts/plots/plot_plambda_qu_sf_ctn_ctk.py

	python3 $< $@

fig/mbh_mstar.pdf: src/python/plot_mbh_mstar.py

	python3 $< $@

fig/xray_luminosity_function.pdf: python/plot_xray_luminosity_function.py

	python3 $< $@

fig/quasar_luminosity_function.pdf: python/plot_quasar_luminosity_function.py

	python3 $< $@

table/catalog_column_description.tex: python/create_table_catalog_column_description.py

	python3 $< 0 > $@

table/catalog_column_description_public.tex: python/create_table_catalog_column_description.py

	python3 $< 1 > $@

font.size: 12.0

font.family: serif

axes.linewidth: 1.0

axes.unicode_minus: False

axes.prop_cycle: cycler('color', ['1f77b4', 'ff7f0e', '2ca02c', 'd62728', '9467bd', '8c564b', 'e377c2', '7f7f7f', 'bcbd22', '17becf'])

axes.autolimit_mode: data

xtick.top: True

xtick.bottom: True

xtick.major.size: 7

xtick.minor.size: 3.5

xtick.major.width: 1.0

xtick.minor.width: 1.0

xtick.direction: in

xtick.minor.visible: True

xtick.major.top: True

xtick.major.bottom: True

xtick.minor.top: True

xtick.minor.bottom: True

ytick.left: True

ytick.right: True

ytick.major.size: 7

ytick.minor.size: 3.5

ytick.major.width: 1.0

ytick.minor.width: 1.0

ytick.direction: in

ytick.minor.visible: True

ytick.major.left: True

ytick.major.right: True

ytick.minor.left: True

ytick.minor.right: True

legend.loc: best

legend.frameon: False

figure.titleweight: normal

figure.figsize: 8.3, 5.85

figure.dpi: 300

image.origin: lower

savefig.format: pdf

savefig.bbox: tight

        ax.legend()

    fig.savefig("fig/xlf_zou2024.pdf")

def test_extrapolation_accuracy():

    """Test the extrapolation accuracy from different extrapolation strategies."""

    lvec = np.linspace(31.0, 35.0, 401)

    zs = 0.5, 1.5, 2.5, 3.5, 4.0, 5.5

    fig, axes = plt.subplots(2, 3, dpi=300, sharex=True, sharey=True)

    for i, ax in enumerate(axes.flatten()):

        z = zs[i]

        ax.text(0.90, 0.90, f"{z=}", transform=ax.transAxes, ha="right", va="top")

        for log_mstar in 9.5, 9.0, 8.5:

            ls = "solid"

            is_extra = (log_mstar < 9.5) | (z > 4.0)

            if is_extra:

                ls = "dotted"

            plambda = get_log_plambda(lvec, log_mstar, zs[i], "all")

            ax.plot(lvec, plambda, ls=ls, label=f"{log_mstar:.1f}", lw=2.0)

    for i in range(3):

        axes[1, i].set_xticks([31, 32, 33, 34, 35])

        axes[1, i].set_xlabel(r"$\log(\lambda_\mathrm{SAR} / \mathrm{erg\,s^{-1}\,M_\odot^{-1}})$")

    for i in range(2):

        axes[i, 0].set_yticks([-6, -5, -4, -3, -2, -1, 0])

        axes[i, 0].set_ylabel(r"$p(\lambda_\mathrm{SAR} | M_\mathrm{star}, z)$")

    axes[0, 0].legend(loc="lower left", frameon=True)

    fig.tight_layout()

    fig.savefig("fig/test_zou_extrapolation_accuracy.pdf", bbox_inches="tight")

if __name__ == "__main__":

    test_extrapolation_accuracy()

#!/usr/bin/env python3

# Author: Akke Viitanen

# Email: akke.viitanen@helsinki.fi

import sys

import matplotlib.pyplot as plt

import numpy as np

from lsst_inaf_agile import zou2024

# plt.style.use("etc/agile.mplstyle")

def plot_plambda_ctn_ctk(fig, ax, log_mstar, z):

    def get_label(idx):

        return [

            "CTN star-forming",

            "CTN quiescent",

            "CTK star-forming",

            "CTK quiescent",

        ][idx % 4]

    def get_linestyle(idx):

        return ["solid", "dashed", "dashdot", "dotted"][idx % 4]

    def get_color(sf_or_qu):

        return "orange" if sf_or_qu == "quiescent" else "purple"

    from itertools import product

    log_lambda = np.arange(31.5, 36, 0.01)

    idx = 0

    for idx, (fun_plambda, sf_or_qu) in enumerate(

        product((zou2024.get_log_plambda, zou2024.get_log_plambda_ctk), ("star-forming", "quiescent"))

    ):

        ax.plot(

            log_lambda,

            fun_plambda(log_lambda, log_mstar, z, sf_or_qu),

            lw=2.0,

            ls=get_linestyle(idx),

            color=get_color(sf_or_qu),

            label=get_label(idx),

        )

    # Set the text

    # NOTE: log(Mstar/Modot) in LaTeX

    mstar_text = r"\log (M_\mathrm{star} / M_\odot)"

    text = "\n".join(

        [

            f"${mstar_text} = {log_mstar:.1f}$",

            # r"$M_\mathrm{star} = 10^{%.1f}\,M_\odot$" % log_mstar,

            f"$z = {z:.1f}$",

        ]

    )

    # ax.text(0.10, 0.10, text, fontsize="medium", transform=ax.transAxes, verticalalignment="bottom")

    ax.text(0.90, 0.90, text, fontsize="medium", transform=ax.transAxes, ha="right", va="top")

    return fig, ax

if __name__ == "__main__":

    # Init

    savefig = sys.argv[1]

    log_mstars = 9.5, 10.5, 11.5

    zs = 0.5, 1.5, 2.5, 3.5

    fig, axes = plt.subplots(

        len(zs),

        len(log_mstars),

        figsize=(len(log_mstars) * 4.8 / 1.5, len(zs) * 6.4 / 2.5),

        sharex=True,

        sharey=True,

    )

    # plot plambda

    for row, z in enumerate(zs):

        for col, log_mstar in enumerate(log_mstars):

            plot_plambda_ctn_ctk(fig, axes[row, col], log_mstar, z)

    # set the limits

    axes[0, 0].set_xlim(31.5, 35)

    axes[0, 0].set_ylim(-6, 0.5)

    # set the labels

    for ax in axes[3, :]:

        # NOTE: xlabel was Msun instead of M_odot

        ax.set_xlabel(r"$\log(\lambda_{\rm SAR}/\mathrm{erg\,s^{-1}\,M_\odot^{-1}})$", fontsize="large")

    for ax in axes[:, 0]:

        ax.set_ylabel(r"$\log p(\lambda_{\rm SAR})$ [1/dex]", fontsize="large")

        # fix the yticks to once per dex

        ax.set_yticks(np.arange(-6, 1))

    # legend

    # axes[0, 0].legend(fontsize="small", loc="upper right")

    axes[0, 0].legend(fontsize="small", loc="lower left")

    # save

    fig.tight_layout(pad=0.10)

    fig.savefig(savefig, bbox_inches="tight")