TransitionListener 2.0.0__py3-none-any.whl

transitionlistener/config.py

@@ -0,0 +1,185 @@
+"""This module contains the configurations.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+import copy
+
+
+class TracingConf:
+    """Phase-tracing and tunneling computation parameters."""
+
+    internal_scale = 1000      # Reference energy scale (internal units); sets the magnitude of the stable minimum.
+    Tmax_factor = 2.5               # Tmax_factor * internal_scale = max tracing temperature.
+    diftol = 1                      # Max field-space distance between two phases (internal units) before they merge.
+    Z2_cutof_factor = -5            # For Z2-symmetric potentials: reject phases with field < Z2_cutof_factor * diftol.
+    tracing_derivative_order = 4    # Finite-difference derivative order: 2 or 4.
+    tracing_field_accuracy = 1e-3   # Target field-space accuracy during tracing (1e-3 works well).
+    tracing_temp_accuracy = 1e-3    # Target temperature accuracy during tracing.
+    gen_mirror_phases = False       # If True, also generate mirror-transformed phases of the potential.
+    nucleation_Ttol = 1e-8          # Nucleation-temperature tolerance (internal units).
+    do_tachyon_test = True          # If True, verify the potential is stable at T = 0.
+    approx_strength_threshold = 1e-4  # Transitions with DV / T^4 below this are treated as second-order.
+    do_high_T_phase_check = True    # Hotfix toggle for high-T phase checks (needed by the vev-flip-flop model).
+
+    tracing_args = {
+        "dtstart": 1e-4,         # Initial trace step for traceMultiMin (scaled by tHigh - tLow).
+        "tjump": 1e-5,           # Branch-jump size when tracing continues after a phase endpoint.
+        "dtabsMax": 20.0,        # Max absolute step is largest of abs(dtstart)*dtabsMax ...
+        "dtfracMax": 0.25,       # ... and t*dtfracMax in internal units.
+        "dtmin": 1e-6,           # Min step (relative to dtstart) before assuming transition ends.
+        "deltaX_tol": 1.2,       # deltaX_tol*deltaX_target = max x-error before shrinking the step.
+        "minratio": 1e-4,        # Smallest/largest Hessian eigenvalue ratio before branch ends.
+        "local_min_args": {      # Forwarded to phases.findApproxLocalMin() from traceMultiMin().
+            "n": 100,            # Interpolation samples along x1->x2 for local-min detection.
+            "edge": 0.05,        # Fraction trimmed off each end before searching.
+        },
+    }
+    """Arguments forwarded to the phase-tracing routines."""
+    tunneling_params = {
+        "tunneling_findProfile_params": {
+            "phitol": 1e-10,     # Field-space tolerance for the overshoot/undershoot profile.
+            "xtol": 1e-10,       # Radial shooting tolerance for the bounce match.
+            "rmin": 1e-4,
+            "rmax": 1e4,
+            "npoints": 500,      # Radial support points for the bounce profile.
+        },
+        "V_spline_samples": 1000,  # Points used to spline V(x) along the bounce path; None evaluates V directly.
+        "tunneling_init_params": {
+            "phi_eps": 1e-6,     # Initial offset from the false vacuum.
+            "rscale": None,      # Manual radial scale; None = auto-estimate.
+        },
+        "deformation_deform_params": {
+            "startstep": 2e-3,
+            "fRatioConv": 2e-2,  # Convergence on normal/tangential force ratio along the path. Auto-tightened to 1e-2 for Ndim>=2 models in generic_potential.__init__.
+            "converge_0": 5.0,   # Early-stop threshold for the force-ratio at the first stage.
+            "fRatioIncrease": 5.0,
+            "maxiter": 500,
+            "verbose": False,
+        },
+    }
+    """Arguments forwarded to the bounce-action / tunneling routines."""
+
+    def __init__(self):
+        """Give every model its own copy of the mutable default dicts."""
+        self.tracing_args = copy.deepcopy(TracingConf.tracing_args)
+        self.tunneling_params = copy.deepcopy(TracingConf.tunneling_params)
+
+
+class PercolationConf:
+    """Settings for the percolation solver."""
+
+    # Solver mode and integral backend.
+    algorithm_mode = "adaptive_step_size"       # "adaptive_step_size" (default) or "fixed_step_size".
+    integral_method = "ode"               # Percolation integral backend: "ode" or "double_integral".
+    time_temperature_mode = "sound_speed" # dT/dt relation: "sound_speed" or "bag".
+
+    # Percolation targets.  Iperc is computed as -ln(1 - f_perc) at use sites.
+    f_perc = 0.28957                      # True-vacuum fraction at percolation.
+    f_start = 1e-3                        # Max initial true-vacuum fraction; below this, widen the T-range.
+    f_final = 0.99                        # Min final true-vacuum fraction for a completed percolation.
+
+    # Iteration controls shared by both percolation passes.
+    weight = 1 / 1.5                      # Fraction of support points spent between Tnuc and Tperc (fixed_step_size mode).
+    maxit = 10                            # Max iterations per percolation pass (step 2 and step 3 each).
+    rel_increment = 0.10                  # Relative T-range growth when the initial range is too small.
+    max_boundary_ratio = 0.45             # Max share of T-range allowed on plateaus where P_true = 0 or 1.
+
+    # Support-bank budget (adaptive step size mode).
+    n_action_min = 15                     # Min support points built before a DZW sweep.
+    n_action_increment = 5                # Support points added per DZW refinement iteration.
+    n_action_max = 60                     # Hard cap on total support points across DZW iterations.
+    max_action_temperatures = 100         # Absolute ceiling on distinct action evaluations per run.
+
+    # fixed_step_size support count.
+    n_action = 30                         # Fixed support count used by the fixed_step_size path.
+
+    # P(T)-jump refinement and final acceptance.
+    large_delta_p_refine_threshold = 0.1  # Neighbour DeltaP above this triggers extra refinement.
+    large_delta_p_success_threshold = 0.2 # Neighbour DeltaP above this blocks acceptance.
+
+    # Diagnostics and optional rescue paths.
+    jitter_GH4_threshold = 1.0            # log10(Gamma/H^4) jitter tolerance before flagging unresolved action.
+    jitter_rescue = True                  # If True, rerun with tunneltight precision on jitter detection.
+    n_jitter_save = 20                    # Max jitter diagnostic samples saved to disk.
+
+    # Observable accuracy targets (step 2 and step 3).
+    acc_tperc = 1e-2                      # Relative accuracy goal on Tperc.
+    acc_tfinal = 1e-2                     # Relative accuracy goal on Tfinal.
+    acc_rh = 1e-2                         # Relative accuracy goal on RH.
+
+    # Strength-based validity flag.
+    weak_threshold = 1e-4                 # Below this alpha at Tperc, the percolation result is flagged invalid.
+
+
+class GWConf:
+    """Settings for calculating the gravitational-wave signal."""
+
+    use_mean_bubble_separation = True  # If True, use mean bubble separation for the GW signal scale.
+    wall_velocity = "LTE"              # "LTE", "c", "WallGo", or a float in (0, 1].
+    bw_collisions = "off"              # Bubble-wall collisions: "off", "full" (kappa_phi=1), or "NLO".
+    turbulence = "off"                 # Turbulence contribution: "off" or a model key.
+    dilution = False                   # If True, apply a dilution factor to the GW signal.
+    equilibrium_DS = True              # Assume the dark sector is in thermal equilibrium with the SM.
+    epsilon_turbulence = 0.1           # Energy fraction redirected into turbulence (0 disables).
+    sound_speed = "compute"            # Sound-speed strategy: "compute" (broken-phase cs) or "1/3" (bag value).
+    coupled_hydrodynamics = True       # Couple the dark and visible sectors in the hydro solve.
+    check_if_T0_global_min = False     # If True, require the T=0 minimum to be global (else just warn).
+
+
+class Configuration:
+    """Container holding one independent configuration object per subsystem."""
+
+    def __init__(self):
+        """Start every model with independent configuration objects."""
+        self.tracingConf = TracingConf()
+        self.gwConf = GWConf()
+        self.percolationConf = PercolationConf()
+
+
+all_observables = {
+    "alpha": R"$\alpha$",
+    "alpha_theta": R"$\alpha_{\theta}$",
+    "alpha_thetabar": R"$\alpha_{\bar\theta}$",
+    "alpha_inf": R"$\alpha_\infty$",
+    "alpha_eq": R"$\alpha_\mathrm{eq}$",
+    "betaH_S3": R"$(\beta /H)_{S_3}$",
+    "betaH_RH": R"$(\beta /H)_{RH}$",
+    "RH": R"$RH$",
+    "Treh_SM_GeV": R"$T^{\mathrm{reh}}_{\mathrm{SM}}$ / $\mathrm{GeV}$",
+    "Tperc_SM_GeV": R"$T^{\mathrm{perc}}_{\mathrm{SM}}$ / $\mathrm{GeV}$",
+    "g_eff_tot_reh": R"$g^{\mathrm{reh}}_{\mathrm{tot}}$",
+    "h_eff_tot_reh": R"$h^{\mathrm{reh}}_{\mathrm{tot}}$",
+    "kappa_phi": R"$\kappa_{\phi}$",
+    "kappa_sw": R"$\kappa_{\mathrm{sw}}$",
+    "kappa_turb": R"$\kappa_{\mathrm{turb}}$",
+    "g0": R"$g_0$",
+    "h0": R"$h_0$",
+    "v_wall": R"$v_{\mathrm{wall}}$",
+    "D": R"$D$",
+    "c_s": R"$c_\mathrm{s}$",
+    "c_s_sym": R"$c_\mathrm{s}^\mathrm{sym}$",
+    "c_s_bro": R"$c_\mathrm{s}^\mathrm{bro}$",
+    "step": R"$\mathrm{step}$",
+    "total_steps": R"$\mathrm{total\ steps}$",
+    "Tnuc_SM_GeV": R"$T^{\mathrm{nuc}}_{\mathrm{SM}}$ / $\mathrm{GeV}$",
+    "Tcrit_SM_GeV": R"$T^{\mathrm{crit}}_{\mathrm{SM}}$ / $\mathrm{GeV}$",
+    "Tf_SM_GeV": R"$T^{\mathrm{final}}_{\mathrm{SM}}$ / $\mathrm{GeV}$",
+    "xi_crit": R"$\xi_{\mathrm{c}}$",
+    "WARNING:too_weak_to_compute_perc": R"$\mathrm{WARNING:} \mathrm{too\ weak\ to\ compute\ perc}$",
+    "WARNING:no_perc_splines": R"$\mathrm{WARNING:} \mathrm{no\ perc\ splines}$",
+    "WARNING:betaH_small": R"$\mathrm{WARNING:} (\beta/H)_{RH} \mathrm{\ too\ small}$",
+    "WARNING:betaH_very_small": R"$\mathrm{WARNING:} (\beta/H)_{RH} \mathrm{\ very\ small}$",
+    "WARNING:betaH_mismatch": R"$\mathrm{WARNING:} (\beta/H)_{S_3} \mathrm{\ vs\ } (\beta/H)_{RH} \mathrm{\ mismatch}$",
+    "WARNING:betaH_nonfinite": R"$\mathrm{WARNING:} (\beta/H)_{S_3} \mathrm{\ or\ } (\beta/H)_{RH} \mathrm{\ nonfinite}$",
+    "WARNING:nucleationRate_nonexponential": R"$\mathrm{WARNING:} \mathrm{nucleation\ rate\ nonexponential}$",
+    "WARNING:spline_tnuc_unavailable": R"$\mathrm{WARNING:} T_\mathrm{nuc} \mathrm{\ spline\ unavailable}$",
+    "WARNING:spline_tnuc_not_reached": R"$\mathrm{WARNING:} T_\mathrm{nuc} \mathrm{\ criterion\ not\ reached}$",
+    "WARNING:spline_tnuc_failed": R"$\mathrm{WARNING:} T_\mathrm{nuc} \mathrm{\ spline\ failed}$",
+    "WARNING:not_T0_global_min": R"$\mathrm{WARNING:} T=0 \mathrm{\ not\ global\ min}$",
+}

transitionlistener/constants.py

@@ -0,0 +1,64 @@
+"""
+Particle physics and cosmological quantities used across TransitionListener.
+
+The numerical values listed here follow the PDG conventions and are expressed
+in natural units whenever possible.  Additional model-specific inputs (SM
+fermion masses, gauge boson pole masses, Wolfenstein CKM parameters, ...)
+are collected in dedicated containers so that individual models can reuse them.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+from __future__ import annotations
+
+import scipy.constants as sc
+
+yr = sc.Julian_year  #: One Julian year in seconds (:math:`365.25` days).
+Mpl_GeV = 1.220910e19  #: Planck mass in GeV.
+Omega_gamma_h2 = 2.473e-5  #: Photon energy density today in units of :math:`h^2`.
+T0_SM_GeV = 2.35253655e-13  #: CMB temperature :math:`T_0 = 2.725\,\\mathrm{K}` in GeV.
+GeV_Hz = 1.0 / 6.582119e-25  #: Conversion between GeV and Hz.
+H100_Hz = 100 / 3.0857e19  #: Hubble constant :math:`H_0 = 100\,\\mathrm{km/s/Mpc}` in Hz.
+Lambda = 2.533e-47  #: Dark-energy density :math:`\\rho_{\\Lambda}` in GeV^4.
+fyr_Hz = 1 / yr  #: Frequency corresponding to one inverse year in Hz.
+
+# ---------------------------------------------------------------------------
+# Standard Model inputs
+# ---------------------------------------------------------------------------
+
+SM_FERMION_MASSES_GEV = {
+    "m_e": 0.510998928e-3,
+    "m_mu": 0.1056583715,
+    "m_tau": 1.77682,
+    "m_u": 0.1,
+    "m_c": 1.51,
+    "m_t": 172.5,
+    "m_d": 0.1,
+    "m_s": 0.1,
+    "m_b": 4.92,
+}
+"""Pole masses of the Standard Model fermions in GeV.
+
+These values serve as the central inputs
+for all Yukawa couplings appearing in TransitionListener models.  They are
+provided as a plain dictionary so that models can access them directly or feed
+them into symbolic pipelines.
+"""
+
+SM_GAUGE_MASSES_GEV = {
+    "mW": 80.385,
+    "mZ": 91.1876,
+}
+"""Pole masses of the electroweak gauge bosons in GeV."""
+
+CW_CONSTANTS = {
+    "scalar": 3.0 / 2.0,
+    "fermion": 3.0 / 2.0,
+    "gauge": 5.0 / 6.0,
+}
+"""Coleman–Weinberg subtraction constants for scalars, fermions, and vectors."""

transitionlistener/counterterms/__init__.py

@@ -0,0 +1,230 @@
+"""
+Counterterm and quantum-correction utilities.
+
+This package bundles the Coleman–Weinberg tensor helpers with the registry and
+solver infrastructure used to generate and apply model-specific counterterms.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Mapping, Tuple, Type
+
+import importlib
+import json
+import pkgutil
+
+from . import cw, tensors
+
+__all__ = [
+    "cw",
+    "tensors",
+    "CounterTerms",
+    "CountertermGenerator",
+    "register_generator",
+    "get_generator",
+    "generate_counterterms",
+]
+
+
+@dataclass(slots=True)
+class CounterTerms:
+    """
+    Generic container for renormalisation counterterms.
+
+    Instead of hard-coding a particular model layout, the container stores an
+    arbitrary mapping from identifiers to floating-point values and exposes it
+    via attribute, item, and dictionary-style access.  This keeps the 2HDM
+    interface backwards compatible while allowing other models to choose their
+    own naming convention.
+    """
+
+    values: Dict[str, float]
+
+    def __post_init__(self) -> None:
+        """Copy the supplied mapping so later mutations do not leak back to the caller."""
+        self.values = dict(self.values)
+
+    def __getattr__(self, name: str) -> float:
+        """Expose stored counterterms through attribute access."""
+        try:
+            return self.values[name]
+        except KeyError as exc:
+            raise AttributeError(f"Unknown counterterm '{name}'.") from exc
+
+    def __getitem__(self, key: str) -> float:
+        """Expose stored counterterms through dictionary-style indexing."""
+        return self.values[key]
+
+    def get(self, key: str, default: float | None = None) -> float | None:
+        """Return ``values[key]`` when present and ``default`` otherwise."""
+        return self.values.get(key, default)
+
+    def as_dict(self) -> Dict[str, float]:
+        """Return a shallow copy of the stored counterterms."""
+        return dict(self.values)
+
+    @classmethod
+    def from_dict(cls, mapping: Mapping[str, float]) -> "CounterTerms":
+        """Build a :class:`CounterTerms` instance from a dictionary."""
+        return cls(dict(mapping))
+
+    @classmethod
+    def from_kwargs(cls, **kwargs: float) -> "CounterTerms":
+        """Build a :class:`CounterTerms` instance from keyword arguments."""
+        return cls(dict(kwargs))
+
+
+class CountertermGenerator:
+    """
+    Base class for SymPy-based counterterm dataset generators.
+
+    Subclasses must implement :meth:`build_dataset`, returning the metadata and
+    tensor dictionary that will be serialised to JSON.
+    """
+
+    model_key: str = "BaseModel"
+    output_filename: str = "counterterms.json"
+
+    def output_path(self) -> Path:
+        """Return the canonical location of the generated tensor JSON file."""
+        project_root = Path(__file__).resolve().parents[3]
+        return project_root / "models" / "generated" / self.output_filename
+
+    def build_dataset(self) -> Tuple[dict, dict]:
+        """Return ``(metadata, tensors)`` describing the generated counterterm dataset."""
+        raise NotImplementedError
+
+    def _convert_sympy(self, data: Any) -> Any:
+        """Recursively turn SymPy objects into JSON-serialisable structures."""
+        import sympy as sp
+
+        if isinstance(data, dict):
+            converted = {}
+            for key, value in data.items():
+                if isinstance(key, tuple):
+                    key_str = str(tuple(key))
+                else:
+                    key_str = str(key)
+                converted[key_str] = self._convert_sympy(value)
+            return converted
+        if isinstance(data, list):
+            return [self._convert_sympy(item) for item in data]
+        if isinstance(data, tuple):
+            return tuple(self._convert_sympy(item) for item in data)
+        if isinstance(data, sp.Basic):
+            return sp.srepr(data)
+        return data
+
+    def to_json(self) -> dict:
+        """Build the JSON payload with metadata and tensor expressions."""
+        metadata, tensors = self.build_dataset()
+        return {"metadata": metadata, "tensors": self._convert_sympy(tensors)}
+
+
+_GENERATOR_REGISTRY: Dict[str, Type[CountertermGenerator]] = {}
+_GENERATORS_LOADED = False
+
+
+def _ensure_generators_loaded() -> None:
+    """Import all counterterm plug-ins so they can register themselves."""
+
+    global _GENERATORS_LOADED
+    if _GENERATORS_LOADED:
+        return
+
+    package_path = Path(__file__).resolve().parent
+    package_name = __name__
+    for module_info in pkgutil.iter_modules([str(package_path)]):
+        name = module_info.name
+        if name.startswith("_") or name == "__pycache__":
+            continue
+        importlib.import_module(f"{package_name}.{name}")
+
+    _GENERATORS_LOADED = True
+
+
+def register_generator(generator_cls: Type[CountertermGenerator]) -> None:
+    """
+    Register a :class:`CountertermGenerator` subclass under its model key (and alias).
+
+    Parameters
+    ----------
+    generator_cls:
+        Concrete generator class providing ``model_key`` and optional ``alias``.
+    """
+
+    for key in (generator_cls.model_key, getattr(generator_cls, "alias", None)):
+        if key:
+            _GENERATOR_REGISTRY[key] = generator_cls
+
+
+def get_generator(model_key: str) -> CountertermGenerator:
+    """
+    Retrieve the generator instance associated with ``model_key``.
+
+    Parameters
+    ----------
+    model_key:
+        Identifier supplied either as a fully-qualified module path or alias.
+
+    Raises
+    ------
+    KeyError
+        If no generator was registered for the provided key.
+    """
+
+    _ensure_generators_loaded()
+
+    try:
+        generator_cls = _GENERATOR_REGISTRY[model_key]
+    except KeyError as exc:
+        raise KeyError(
+            f"No counterterm generator registered for '{model_key}'."
+        ) from exc
+    return generator_cls()
+
+
+def generate_counterterms(
+    model_key: str,
+    *,
+    force: bool = False,
+    output: Path | None = None,
+) -> Path:
+    """
+    Generate (or reuse) the curvature tensor dataset for the given model.
+
+    Parameters
+    ----------
+    model_key:
+        Identifier resolving to a registered generator class.
+    force:
+        If ``True`` the JSON file is recreated even when a previous version exists.
+    output:
+        Optional override for the output path. When omitted, the generator default
+        (``models/generated/<name>.json``) is used.
+
+    Returns
+    -------
+    Path
+        Filesystem path of the (re)generated JSON file.
+    """
+
+    generator = get_generator(model_key)
+    out_path = output or generator.output_path()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    if out_path.exists() and not force:
+        return out_path
+
+    payload = generator.to_json()
+    with out_path.open("w", encoding="utf-8") as fh:
+        json.dump(payload, fh, indent=2)
+    return out_path