freepaths 2.4.3__tar.gz → 2.5.1__tar.gz

{freepaths-2.4.3 → freepaths-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.4.3
+Version: 2.5.1
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -21,7 +21,6 @@ Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: scipy
-Requires-Dist: imageio
 Requires-Dist: colorama
 Dynamic: author
 Dynamic: author-email

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/__main__.py

@@ -7,7 +7,7 @@ from colorama import Fore, Style
 
 from freepaths.options import SimulationMode
 
-__version__ = "2.4.3"
+__version__ = "2.5.1"
 
 colorama.init()
 

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/animation.py

@@ -3,9 +3,9 @@
 import sys
 import os
 import shutil
-import imageio
 import numpy as np
 import matplotlib.pyplot as plt
+from PIL import Image
 
 from freepaths.config import cf
 from freepaths.output_structure import draw_structure_top_view
@@ -14,7 +14,7 @@ from freepaths.output_structure import draw_structure_top_view
 def generate_frames_xy():
     """Generate animation frames with phonon paths"""
 
-    data = np.genfromtxt("Data/Phonon paths.csv",
+    data = np.genfromtxt("Data/Particle paths.csv",
                          unpack=False,
                          delimiter=',',
                          skip_header=1,
@@ -77,21 +77,20 @@ def generate_frames_xy():
 def generate_animation_xy():
     """Generate animation of phonon path in XY plane"""
     sys.stdout.write(f"\rAnimation: creating animation file")
-    images = []
-    filenames = os.listdir("Frames/")
-    for filename in filenames:
-        images.append(imageio.imread(f"Frames/{filename}"))
 
-    # Create a GIF file:
-    imageio.mimsave("Animated paths XY.gif", images,
-                    duration=1000 * 1/cf.output_animation_fps, subrectangles=True)
-
-    # Create an MP4 file:
-    # writer = imageio.get_writer('Animated paths XY.mp4', fps=cf.output_animation_fps)
-
-    # for im in images:
-        # writer.append_data(imageio.imread(im))
-    # writer.close()
+    # Sort the frames so the GIF plays in the order they were rendered.
+    # os.listdir returns entries in arbitrary filesystem order (unsorted on
+    # macOS/APFS), which produced out-of-order animations. Filtering to the
+    # frame_*.png files also guards against stray files (e.g. .DS_Store).
+    filenames = sorted(f for f in os.listdir("Frames/") if f.endswith(".png"))
+
+    # Assemble the GIF with Pillow (already a matplotlib dependency), so no
+    # extra imaging library is required. Frames are converted to a palette
+    # image for GIF; duration is milliseconds per frame, loop=0 loops forever.
+    frames = [Image.open(f"Frames/{name}").convert("RGB").convert("P", palette=Image.ADAPTIVE)
+              for name in filenames]
+    frames[0].save("Animated paths XY.gif", save_all=True, append_images=frames[1:],
+                   duration=1000 / cf.output_animation_fps, loop=0, optimize=True)
 
 
 def delete_frames():

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/config.py

@@ -91,6 +91,7 @@ class Config:
         self.number_of_virtual_timesteps = NUMBER_OF_VIRTUAL_TIMESTEPS
         self.ignore_faulty_particles = IGNORE_FAULTY_PARTICLES
         self.gradient_fit_range = GRADIENT_FIT_RANGE
+        self.temperature_profile_x_range = TEMPERATURE_PROFILE_X_RANGE
 
         # Material parameters:
         self.media = MEDIA
@@ -98,7 +99,12 @@ class Config:
 
         # Internal scattering:
         self.include_internal_scattering = INCLUDE_INTERNAL_SCATTERING
-        self.use_dispersion_heat_capacity = USE_DISPERSION_HEAT_CAPACITY
+        self.phonon_hydrodynamic = PHONON_HYDRODYNAMIC
+        self.number_of_hydrodynamic_preruns = NUMBER_OF_HYDRODYNAMIC_PRERUNS
+        self.hydrodynamic_preruns_weight = HYDRODYNAMIC_PRERUNS_WEIGHT
+        self.number_of_hydrodynamic_prerun_particles = NUMBER_OF_HYDRODYNAMIC_PRERUN_PARTICLES
+        self.hydrodynamic_normal_resistive = HYDRODYNAMIC_NORMAL_RESISTIVE
+        self.isotope_c13_concentration = ISOTOPE_C13_CONCENTRATION
         self.max_number_of_scattering_events = MAX_NUMBER_OF_SCATTERING_EVENTS
         self.grain_size = GRAIN_SIZE
         self.grain_size_std = GRAIN_SIZE_STD
@@ -143,7 +149,6 @@ class Config:
         self.holes = HOLES
         self.pillars = PILLARS
         self.interfaces = INTERFACES
-        self.bulks = BULKS
 
         # Multiprocessing:
         self.num_workers = NUMBER_OF_PROCESSES
@@ -171,6 +176,11 @@ class Config:
                           f"See the documentation at {WEBSITE}")
             sys.exit()
 
+        if not (0.0 <= self.temperature_profile_x_range[0] < self.temperature_profile_x_range[1] <= 1.0):
+            logging.error("Parameter TEMPERATURE_PROFILE_X_RANGE must be a pair (start, end) with 0 <= start < end <= 1.\n" +
+                          f"See the documentation at {WEBSITE}")
+            sys.exit()
+
         if self.number_of_timeframes <= self.number_of_stabilization_timeframes:
             logging.error("Parameter NUMBER_OF_STABILIZATION_TIMEFRAMES exceeds or equal to NUMBER_OF_TIMEFRAMES.\n" +
                           "Leave at least one timeframe after NUMBER_OF_STABILIZATION_TIMEFRAMES.\n" +

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/data.py

@@ -67,6 +67,10 @@ class GeneralData(Data):
         self.final_frequencies = []
         self.initial_energies = []
         self.group_velocities = []
+        # Wavevector of each particle, row-aligned with final_frequencies/group_velocities.
+        # Recorded separately because k cannot be recovered from f and v_g on a curved
+        # dispersion, and the physical wavelength is 2*pi/k (see Phonon.wavelength):
+        self.wavevectors = []
         self.travel_times = []
         self.mean_free_paths = []
         self.thermal_conductivity = []
@@ -86,6 +90,7 @@ class GeneralData(Data):
         else:
             self.final_frequencies.append(pt.f)
             self.group_velocities.append(pt.speed)
+            self.wavevectors.append(pt.k)
             self.branches.append(pt.branch_number)
 
     def save_flight_data(self, flight, mode=None):
@@ -120,6 +125,7 @@ class GeneralData(Data):
         else:
             np.savetxt("Data/All final frequencies.csv", self.final_frequencies, fmt='%2.4e', header="f [Hz]", encoding='utf-8')
             np.savetxt("Data/All group velocities.csv", self.group_velocities, fmt='%.4f', header="Vg [m//s]", encoding='utf-8')
+            np.savetxt("Data/All wavevectors.csv", self.wavevectors, fmt='%2.4e', header="k [1//m]", encoding='utf-8')
         if mode is SimulationMode.PHONON_TRACING:
             np.savetxt("Data/All exit angles.csv", self.exit_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
             np.savetxt("Data/All initial angles.csv", self.initial_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
@@ -147,6 +153,7 @@ class GeneralData(Data):
             'free_paths': self.free_paths,
             'final_frequencies': self.final_frequencies,
             'group_velocities': self.group_velocities,
+            'wavevectors': self.wavevectors,
             'travel_times': self.travel_times,
             'mean_free_paths': self.mean_free_paths,
             'thermal_conductivity': self.thermal_conductivity,
@@ -157,6 +164,63 @@ class GeneralData(Data):
         }
 
 
+class SpecularityData(Data):
+    """
+    Running sums behind the specular scattering probability report (MFP-sampling mode).
+
+    The reported kappa-weighted specularity is a weighted mean over modes,
+    sum(kappa_i * f_i) / sum(kappa_i) with f_i = specular_i / (specular_i + diffuse_i),
+    so it accumulates in four fixed-size arrays and never needs the per-mode tallies
+    kept around. That matters: storing them was one 10-integer row per phonon in memory
+    and on disk, which scales with NUMBER_OF_PARTICLES for a result that is 10 numbers.
+    Arrays are indexed by flight.BOUNDARY_CATEGORIES and merged across the branch
+    workers by Data.read_data, whose "+" is elementwise on numpy arrays.
+    """
+
+    def __init__(self):
+        """Initialize the accumulators, one entry per boundary category"""
+        from freepaths.flight import BOUNDARY_CATEGORIES
+        self.specular_events = np.zeros(len(BOUNDARY_CATEGORIES))
+        self.diffuse_events = np.zeros(len(BOUNDARY_CATEGORIES))
+        self.kappa_weighted_specular = np.zeros(len(BOUNDARY_CATEGORIES))
+        self.kappa_of_scattered = np.zeros(len(BOUNDARY_CATEGORIES))
+
+    def add_particle(self, flight):
+        """Fold one finished flight into the running sums"""
+        events = np.array(flight.boundary_events, dtype=float).reshape(-1, 2)
+        specular, diffuse = events[:, 0], events[:, 1]
+        total = specular + diffuse
+        self.specular_events += specular
+        self.diffuse_events += diffuse
+        # Only modes that actually hit a given boundary enter that boundary's mean:
+        scattered = total > 0
+        kappa = flight.thermal_conductivity
+        self.kappa_weighted_specular[scattered] += kappa * specular[scattered] / total[scattered]
+        self.kappa_of_scattered[scattered] += kappa
+
+    def write_into_files(self):
+        """Write the specular scattering probabilities into a file"""
+        from freepaths.flight import BOUNDARY_CATEGORIES
+        total = self.specular_events + self.diffuse_events
+        with np.errstate(invalid='ignore', divide='ignore'):
+            per_event = 100 * self.specular_events / total
+            per_kappa = 100 * self.kappa_weighted_specular / self.kappa_of_scattered
+        rows = [[per_event[i], per_kappa[i], total[i]] for i in range(len(BOUNDARY_CATEGORIES))]
+        np.savetxt("Data/Specular scattering probability.csv", np.array(rows), fmt='%2.4e', delimiter=',',
+                   header="Boundary: " + ", ".join(BOUNDARY_CATEGORIES)
+                          + "\nSpecular per event [%], Specular kappa-weighted [%], Total events",
+                   encoding='utf-8')
+
+    def dump_data(self):
+        """Return data of a process in the form of a dictionary to be attached to the global data"""
+        return {
+            'specular_events': self.specular_events,
+            'diffuse_events': self.diffuse_events,
+            'kappa_weighted_specular': self.kappa_weighted_specular,
+            'kappa_of_scattered': self.kappa_of_scattered,
+        }
+
+
 class ScatteringData(Data):
     """Statistics of particle scattering events"""
 

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/default_config.py

@@ -55,9 +55,6 @@ MEAN_MAPPING_CONSTANT            = 5e-6 # [m²]
 
 FERMI_LEVEL_LOWER_BOUND          = -0.2  # [eV] lower end of post-processing Fermi level sweep
 FERMI_LEVEL_UPPER_BOUND          =  0.1  # [eV] upper end of post-processing Fermi level sweep;
-# far above the band edge the Fermi window leaves the sampled energy range and
-# the MC results become noisy, so there is little point in sweeping further
-
 
 # Animation:
 OUTPUT_PATH_ANIMATION            = False
@@ -68,6 +65,7 @@ NUMBER_OF_PIXELS_X               = 7
 NUMBER_OF_PIXELS_Y               = 67
 IGNORE_FAULTY_PARTICLES          = False
 GRADIENT_FIT_RANGE               = (0.1, 0.9)
+TEMPERATURE_PROFILE_X_RANGE      = (0.0, 1.0)
 
 # Material parameters:
 MEDIA                            = "Si"
@@ -76,47 +74,20 @@ MEDIA_FERMI_LEVEL                = None
 # Internal scattering:
 INCLUDE_INTERNAL_SCATTERING      = True
 
-# Phonon frequencies and branches are always sampled from the tabulated dispersion
-# (weight k^2 dk per bin, heat-capacity weighting, group-velocity weighting at the
-# source), so particles are equal-energy deviational bundles and the thermal maps
-# record a constant weight per phonon. At inelastic (anharmonic) internal scattering
-# events the branch and frequency are re-drawn from the collision-rate-weighted
-# distribution (Peraud & Hadjiconstantinou, PRB 84, 205331 (2011)), restoring local
-# thermal equilibrium of the phonon population. Elastic internal events (impurity/alloy
-# scattering) conserve the mode and only randomize the direction. This applies to the
-# phonon tracing mode; MFP sampling and electron modes keep the particle identity by
-# construction.
-
-# Convert deposited particle energy into the temperature profile using the
-# dispersion-only heat capacity (Material.dispersion_heat_capacity, summed only
-# over the branches in the tabulated dispersion) instead of the experimental
-# heat capacity fit (Material.assign_heat_capacity). On by default because it
-# makes the reported temperature and kappa self-consistent with the
-# dispersion-based sampling/rethermalization scheme and the model's own RTA
-# integral. Set to False to use the real material heat capacity instead (e.g.
-# including optical branches absent from the tabulated dispersion):
-USE_DISPERSION_HEAT_CAPACITY     = True
-
-# MFP sampling mode only (no effect in phonon tracing, where particles must keep
-# going for the full budget to build the flux map): end a phonon's flight early
-# once it has accumulated this many free-path segments, instead of always running
-# to NUMBER_OF_TIMESTEPS. A short-tau, low-velocity phonon takes tiny hops and
-# diffuses so slowly that it essentially never reaches a domain boundary, but its
-# mean free path already converges after a modest number of scattering events, so
-# running it to the full timestep budget is wasted compute. 1000 is on by default,
-# since it was validated (bulk Si MFP-sampling convergence study, Data/BulkSi_Phonon_MFP/)
-# to give the same result as 5000 while being far cheaper. Set to None to disable
-# (run to the timestep budget or a boundary, as before):
+# Phonon hydrodynamic transport.
+PHONON_HYDRODYNAMIC              = False
+NUMBER_OF_HYDRODYNAMIC_PRERUNS   = 5
+HYDRODYNAMIC_PRERUNS_WEIGHT      = 0.8
+NUMBER_OF_HYDRODYNAMIC_PRERUN_PARTICLES = None
+
+# Diagnostic control: when True, Normal events still fire but redraw the direction 
+# randomly instead of biased toward the local drift
+HYDRODYNAMIC_NORMAL_RESISTIVE    = False
+ISOTOPE_C13_CONCENTRATION        = 0.0
+
 MAX_NUMBER_OF_SCATTERING_EVENTS  = 1000
 
 # Grain boundary scattering (polycrystalline materials):
-# GRAIN_SIZE sets the mean grain diameter [m]. None disables grain boundary scattering entirely.
-# GRAIN_SIZE_STD sets the standard deviation [m]; the grain size is drawn per phonon from a
-# lognormal distribution with this mean and std. Set to 0 for monodisperse (single grain size).
-# GRAIN_ROUGHNESS is the RMS disorder width of the grain boundary [m], used in a Soffer-type
-# specularity factor: at low frequencies (long wavelengths) the boundary appears smooth and
-# phonons pass through; at high frequencies it acts as a classical diffuse scatterer.
-# Typical values: GRAIN_SIZE 100 nm – 10 µm, GRAIN_ROUGHNESS 0.5–2 nm.
 GRAIN_SIZE                       = None
 GRAIN_SIZE_STD                   = 0.0
 GRAIN_ROUGHNESS                  = 1e-9
@@ -158,7 +129,6 @@ INTERFACE_ROUGHNESS              = 0.2e-9
 HOLES                            = []
 PILLARS                          = []
 INTERFACES                       = []
-BULKS                            = []
 
 # Multiprocessing:
 NUMBER_OF_PROCESSES              = 10

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/electron.py

@@ -127,15 +127,16 @@ class Electron(Particle):
         """
         self.f = self.energy / h
 
-    def assign_speed(self, material):
+    def speed_in(self, material):
         """
-        Assign speed to an electron using group velocity and considering parabolic energy-k relation and conduction minimum at 0
+        Speed of an electron in the given material from the parabolic energy-k relation,
+        with the conduction minimum at 0
         """
         if self.is_electron_carrier:
             effective_mass = material.effective_electron_dos_mass
         else:
             effective_mass = material.effective_hole_dos_mass
-        self.speed = (2*self.energy/(effective_mass))**(0.5)
+        return (2*self.energy/(effective_mass))**(0.5)
 
     def assign_internal_scattering_time(self, material):
         """

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/flight.py

@@ -4,6 +4,13 @@ from math import cos
 import numpy as np
 
 from freepaths.config import cf
+from freepaths.scattering_types import Scattering
+
+
+# Boundary categories tallied per particle by Flight.record_boundary_events. The order
+# fixes the index order of Flight.boundary_events, of the data.SpecularityData
+# accumulators, and of the rows of "Data/Specular scattering probability.csv".
+BOUNDARY_CATEGORIES = ('Side walls', 'Top and bottom walls', 'Hole walls', 'Pillar walls', 'Interfaces')
 
 
 class Path:
@@ -50,6 +57,16 @@ class Flight:
         # impurity) and boundary (diffuse surface) spectra in the MFP-sampling mode:
         self._internal_count = 0
         self._boundary_count = 0
+        # Specular and diffuse boundary event counts of THIS particle, as flat
+        # [specular, diffuse] pairs per entry of BOUNDARY_CATEGORIES. The aggregate
+        # ScatteringData counters cannot answer "how specular is a given mode", because
+        # they sum events over all particles: a mode that scatters diffusely lingers in
+        # the structure and accumulates far more events than one that reflects
+        # specularly and streams straight out. Folded into data.SpecularityData as soon
+        # as the flight ends and then discarded with the Flight, so nothing per-mode
+        # accumulates; only filled in the MFP-sampling mode, which is where it is
+        # reported (see output_info.weighted_specularity_information).
+        self.boundary_events = [0] * (2 * len(BOUNDARY_CATEGORIES))
         self.hole_diff_scattering_angles = []
         self.hole_spec_scattering_angles = []
         self.thermal_conductivity = 0.0
@@ -97,6 +114,19 @@ class Flight:
         if not cf.low_memory_usage:
             self.free_paths.append(self.free_path)
 
+    def record_boundary_events(self, scattering_types):
+        """Tally this timestep's boundary events by category and by specularity."""
+        categories = (scattering_types.walls, scattering_types.top_bottom,
+                      scattering_types.holes, scattering_types.pillars,
+                      # interfaces covers reflection AND transmission, so counting
+                      # interfaces_transmission as well would double-count them:
+                      scattering_types.interfaces)
+        for index, scattering in enumerate(categories):
+            if scattering is Scattering.SPECULAR:
+                self.boundary_events[2 * index] += 1
+            elif scattering is Scattering.DIFFUSE:
+                self.boundary_events[2 * index + 1] += 1
+
     def record_scattering_channel(self, is_internal, is_boundary):
         """Tally the channel of a diffuse event that ends a free-path segment, so the
         total scattering rate can later be split into internal and boundary spectra."""

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/interface_smmm.py

@@ -31,6 +31,19 @@ def alpha_spec(theta_i, vg_i, vg_j, rho_i, rho_j):
     """
     Specular transmission coefficient (AMM) between two materials.
 
+    Ran & Cao, PRB 110, 024302 (2024), Eq. (20):
+
+        alpha = 4*A*B / (A + B)**2,   A = Z_j/Z_i,  B = cos(theta_j)/cos(theta_i)
+
+    which is the standard oblique-incidence acoustic result 4*W_i*W_j/(W_i + W_j)**2
+    with the angle-corrected impedances W = Z/cos(theta), i.e. the COSINES IN THE
+    DENOMINATOR ARE CROSSED: (Z_i*cos(theta_j) + Z_j*cos(theta_i))**2. Writing them
+    uncrossed agrees at normal incidence but over-estimates transmission at oblique
+    incidence (Si/SiGe LA at 1 THz: 0.990 vs 0.928 at 60 deg).
+
+    Note this is Eq. (20), not Eq. (25): the MTM detailed-balance prefactor
+    min{1, P_j*C_j*vg_j**3 / (P_i*C_i*vg_i**3)} of Eq. (25) is deliberately not applied.
+
     Parameters:
     theta_i -- incidence angle
     vg_i, vg_j -- group velocities of media i and j
@@ -49,7 +62,7 @@ def alpha_spec(theta_i, vg_i, vg_j, rho_i, rho_j):
         Z_j = rho_j * vg_j
 
         num = 4 * Z_i * Z_j * abs(math.cos(theta_i)) * abs(math.cos(theta_j))
-        den = (Z_i * abs(math.cos(theta_i)) + Z_j * abs(math.cos(theta_j))) ** 2
+        den = (Z_i * abs(math.cos(theta_j)) + Z_j * abs(math.cos(theta_i))) ** 2
         return num / den
     except:
         return 0.0
@@ -114,30 +127,3 @@ def alpha_total_2T(theta_i, vg_i, vg_j, rho_i, rho_j, omega_i, omega_j, material
     T2 = P_j * a_s2 + (1 - P_j) * a_d2
 
     return T1 * T2
-
-
-def alpha_total_1T(theta_i, vg_i, vg_j, rho_i, rho_j, omega_i, omega_j, material_i, material_j, branch_number, roughness):
-    """Transmission model for 1 transmission : ex: Si → Ge for small rectangle inside single crystal Si"""
-
-    k_i = get_k_from_omega(omega_i, material_i, branch_number)
-    k_j = get_k_from_omega(omega_j, material_j, branch_number)
-
-    wavelength_i = lambda_from_k(k_i)
-    wavelength_j = lambda_from_k(k_j)
-
-    P_i = math.exp(-16 * math.pi**2 * roughness**2 / wavelength_i**2)
-    P_j = math.exp(-16 * math.pi**2 * roughness**2 / wavelength_j**2)
-
-    try:
-        sin_theta_t = (vg_i / vg_j) * math.sin(theta_i)
-        if abs(sin_theta_t) > 1:
-            return 0.0  # Totle reflection at the entry
-    except:
-        return 0.0
-
-    a_s = alpha_spec(theta_i, vg_i, vg_j, rho_i, rho_j)
-    a_d = alpha_diff(k_i, k_j, P_i, P_j)
-    T_1T = P_i * a_s + (1 - P_i) * a_d
-
-    return T_1T
-

{freepaths-2.4.3 → freepaths-2.5.1}/freepaths/main_mfp_sampling.py

@@ -20,11 +20,10 @@ from freepaths.run_particle import run_particle
 from freepaths.phonon import Phonon
 from freepaths.flight import Flight
 from freepaths.options import SimulationMode
-from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
-from freepaths.materials import Si, SiC, Graphite, SiGe
+from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData, SpecularityData
+from freepaths.materials import create_material, get_media_class
 from freepaths.maps import ScatteringMap
 from freepaths.output_info import output_general_information, output_scattering_information, output_parameter_warnings
-from freepaths.materials import get_media_class
 from freepaths.output_plots import plot_data
 
 
@@ -78,17 +77,8 @@ def _run_branch(branch_number, shared_list, shared_progress):
     # Each worker builds its own material instance so the dispersion is
     # sampled with the correct number of points (number_of_particles + 1
     # intervals → number_of_particles midpoints):
-    if cf.media == "Si":
-        material = Si(cf.temp, num_points=cf.number_of_particles + 1)
-    elif cf.media == "SiGe":
-        material = SiGe(cf.temp, num_points=cf.number_of_particles + 1)
-    elif cf.media == "SiC":
-        material = SiC(cf.temp, num_points=cf.number_of_particles + 1)
-    elif cf.media == "Graphite":
-        material = Graphite(cf.temp, num_points=cf.number_of_particles + 1)
-    else:
-        logging.error(f"Material {cf.media} is not supported")
-        return
+    material = create_material(cf.media, cf.temp, num_points=cf.number_of_particles + 1,
+                               isotope_c13_concentration=cf.isotope_c13_concentration)
 
     # Local data structures — merged into the global ones after all workers finish:
     scatter_stats = ScatteringData()
@@ -97,9 +87,13 @@ def _run_branch(branch_number, shared_list, shared_progress):
     places_stats = TriangleScatteringData()
     path_stats = PathData()
     scatter_maps = ScatteringMap()
+    specularity_stats = SpecularityData()
 
     total_thermal_conductivity = 0.0
     total_kappa_variance = 0.0
+    total_kappa1 = 0.0        # Callaway kappa1 accumulator (uses combined tau_C)
+    total_k2_num = 0.0        # Callaway kappa2 numerator sum:   w * tau_C / tau_N
+    total_k2_den = 0.0        # Callaway kappa2 denominator sum:  w * tau_C / (tau_N * tau_R)
     last_pct = -1
 
     for index in range(cf.number_of_particles):
@@ -122,11 +116,31 @@ def _run_branch(branch_number, shared_list, shared_progress):
         part = scipy.constants.hbar * omega / (scipy.constants.k * cf.temp)
         c_p = scipy.constants.k * part**2 * math.exp(part) / (math.exp(part) - 1)**2
 
-        # Thermal conductivity contribution from this k-point (Ref. Phys. Rev. 132 2461, 1963):
+        # Thermal conductivity contribution from this k-point (Ref. Phys. Rev. 132 2461, 1963).
+        # The measured mean free path is limited by resistive (Umklapp + isotope) and boundary
+        # scattering, so mean_relax_time is the Callaway resistive time tau_R (Normal scattering
+        # does not fire in the MFP-sampling mode). weight is the common per-mode integrand factor.
         mean_relax_time = flight.mean_free_path / phonon.speed
-        flight.thermal_conductivity = (1 / (6 * math.pi**2)) * c_p * phonon.speed**2 * mean_relax_time * k_vector**2 * d_k_vector
+        weight = (1 / (6 * math.pi**2)) * c_p * phonon.speed**2 * k_vector**2 * d_k_vector
+        flight.thermal_conductivity = weight * mean_relax_time          # single-mode RTA (SMRT)
         total_thermal_conductivity += flight.thermal_conductivity
 
+        # Callaway dual-relaxation correction (Callaway, Phys. Rev. 113, 1046 (1959)):
+        # kappa = kappa1 + kappa2, with 1/tau_C = 1/tau_R + 1/tau_N. kappa1 uses the combined
+        # tau_C (Normal provisionally counted as resistive); kappa2 is the momentum-recovery term
+        # kappa2 = (sum w*tau_C/tau_N)^2 / (sum w*tau_C/(tau_N*tau_R)), accumulated linearly here
+        # and combined in main(). tau_C/tau_N = tau_C*normal_rate. Only computed when
+        # PHONON_HYDRODYNAMIC is on (the Normal / momentum-recovery treatment); otherwise
+        # normal_rate = 0 and kappa1 collapses to the standard SMRT conductivity.
+        normal_rate = material.phonon_normal_rate(omega) if cf.phonon_hydrodynamic else 0.0
+        if normal_rate > 0 and mean_relax_time > 0:
+            tau_C = 1.0 / (1.0 / mean_relax_time + normal_rate)
+            total_kappa1 += weight * tau_C
+            total_k2_num += weight * tau_C * normal_rate
+            total_k2_den += weight * tau_C * normal_rate / mean_relax_time
+        else:
+            total_kappa1 += weight * mean_relax_time
+
         # This mode's kappa is linear in its mean free path, so its variance
         # propagates directly through the same proportionality (kappa_i / mfp_i):
         if flight.mean_free_path > 0:
@@ -135,6 +149,7 @@ def _run_branch(branch_number, shared_list, shared_progress):
 
         general_stats.save_particle_data(phonon, SimulationMode.PHONON_MFP_SAMPLING)
         general_stats.save_flight_data(flight, SimulationMode.PHONON_MFP_SAMPLING)
+        specularity_stats.add_particle(flight)
 
         if index < cf.output_trajectories_of_first:
             path_stats.save_particle_path(flight)
@@ -143,12 +158,16 @@ def _run_branch(branch_number, shared_list, shared_progress):
     shared_list.append({
         'total_thermal_conductivity': total_thermal_conductivity,
         'total_kappa_variance': total_kappa_variance,
+        'total_kappa1': total_kappa1,
+        'total_k2_num': total_k2_num,
+        'total_k2_den': total_k2_den,
         'scatter_stats': scatter_stats.dump_data(),
         'general_stats': general_stats.dump_data(),
         'segment_stats': segment_stats.dump_data(),
         'places_stats': places_stats.dump_data(),
         'path_stats': path_stats.dump_data(),
         'scatter_maps': scatter_maps.dump_data(),
+        'specularity_stats': specularity_stats.dump_data(),
     })
 
 
@@ -211,18 +230,26 @@ def main(input_file, mode: SimulationMode):
     places_stats = TriangleScatteringData()
     path_stats = PathData()
     scatter_maps = ScatteringMap()
+    specularity_stats = SpecularityData()
     total_thermal_conductivity = 0.0
     total_kappa_variance = 0.0
+    total_kappa1 = 0.0
+    total_k2_num = 0.0
+    total_k2_den = 0.0
 
     for result in shared_list:
         total_thermal_conductivity += result['total_thermal_conductivity']
         total_kappa_variance += result['total_kappa_variance']
+        total_kappa1 += result['total_kappa1']
+        total_k2_num += result['total_k2_num']
+        total_k2_den += result['total_k2_den']
         scatter_stats.read_data(result['scatter_stats'])
         general_stats.read_data(result['general_stats'])
         segment_stats.read_data(result['segment_stats'])
         places_stats.read_data(result['places_stats'])
         path_stats.read_data(result['path_stats'])
         scatter_maps.read_data(result['scatter_maps'])
+        specularity_stats.read_data(result['specularity_stats'])
 
     # Create the output folder and copy input file:
     if not os.path.exists("Results/" + cf.output_folder_name):
@@ -235,6 +262,7 @@ def main(input_file, mode: SimulationMode):
     # Save data and generate plots:
     general_stats.write_into_files(mode)
     scatter_stats.write_into_files()
+    specularity_stats.write_into_files()
     segment_stats.write_into_files()
     if cf.output_scattering_map:
         scatter_maps.write_into_files()
@@ -267,14 +295,32 @@ def main(input_file, mode: SimulationMode):
                fmt='%2.4e', delimiter=',',
                header="K_material SEM [W/mK], K_effective SEM [W/mK]", encoding='utf-8')
 
+    # Callaway dual-relaxation conductivity kappa = kappa1 + kappa2 (momentum-recovery term).
+    # Only written in hydrodynamic mode (the Normal-process treatment); in the standard RTA the
+    # -s output is unchanged. Kept in a separate file so the positional indexers of
+    # "Thermal conductivity from MFP.csv" are not disturbed. See main_mfp_sampling._run_branch.
+    kappa2 = kappa_callaway = None
+    if cf.phonon_hydrodynamic:
+        kappa2 = (total_k2_num ** 2 / total_k2_den) if total_k2_den > 0 else 0.0
+        kappa_callaway = total_kappa1 + kappa2
+        np.savetxt("Data/Thermal conductivity Callaway.csv",
+                   np.array([[total_kappa1, kappa2, kappa_callaway]]),
+                   fmt='%2.4e', delimiter=',',
+                   header="kappa1 [W/mK], kappa2 [W/mK], kappa_Callaway [W/mK]", encoding='utf-8')
+
     sys.stdout.write("\rAnalyzing the data...")
     plot_data(mode, cf)
 
     output_general_information(start_time, general_stats, mode)
-    output_scattering_information(scatter_stats)
+    output_scattering_information(scatter_stats, specularity_stats, mode)
     output_parameter_warnings(mode, general_stats)
     sys.stdout.write(f'\rSee the results in {Fore.GREEN}Results/{cf.output_folder_name}{Style.RESET_ALL}\n')
-    sys.stdout.write(f"\rMaterial thermal conductivity = {Fore.GREEN}{total_thermal_conductivity:.5f} ± {kappa_sem:.5f}{Style.RESET_ALL} W/m·K\n")
+    if cf.phonon_hydrodynamic:
+        sys.stdout.write(f"\rMaterial thermal conductivity (SMRT) = {Fore.GREEN}{total_thermal_conductivity:.5f} ± {kappa_sem:.5f}{Style.RESET_ALL} W/m·K\n")
+        sys.stdout.write(f"\rMaterial thermal conductivity (Callaway) = {Fore.GREEN}{kappa_callaway:.5f}{Style.RESET_ALL} W/m·K "
+                         f"(kappa1 {total_kappa1:.2f} + kappa2 {kappa2:.2f})\n")
+    else:
+        sys.stdout.write(f"\rMaterial thermal conductivity = {Fore.GREEN}{total_thermal_conductivity:.5f} ± {kappa_sem:.5f}{Style.RESET_ALL} W/m·K\n")
     if cf.holes:
         sys.stdout.write(f"\rEffective thermal conductivity = {Fore.GREEN}{effective_thermal_conductivity:.5f} ± {effective_kappa_sem:.5f}{Style.RESET_ALL} W/m·K "
                          f"(porosity {porosity:.1%}, Eucken factor {eucken_factor:.3f})\n")