freepaths 2.3.2__tar.gz → 2.3.3__tar.gz

{freepaths-2.3.2 → freepaths-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.3.2
+Version: 2.3.3
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/__main__.py

@@ -7,7 +7,7 @@ from colorama import Fore, Style
 
 from freepaths.particle_types import ParticleType
 
-__version__ = "2.3.2"
+__version__ = "2.3.3"
 
 colorama.init()
 

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/config.py

@@ -69,6 +69,8 @@ class Config:
         self.electron_mfp = ELECTRON_MFP
         self.mean_mapping_constant = MEAN_MAPPING_CONSTANT
         self.is_carrier_electron = IS_CARRIER_ELECTRON
+        self.fermi_level_lower_bound = FERMI_LEVEL_LOWER_BOUND
+        self.fermi_level_upper_bound = FERMI_LEVEL_UPPER_BOUND
 
         # Animation:
         self.output_path_animation = OUTPUT_PATH_ANIMATION

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/data.py

@@ -66,12 +66,6 @@ class GeneralData(Data):
         self.travel_times = []
         self.mean_free_paths = []
         self.thermal_conductivity = []
-        self.interfaces_angles = []
-        self.interfaces_transmission_factor = []
-        self.interfaces_wavelength = []
-        self.interfaces_frequency = []
-        self.interfaces_mode = []
-
     def save_particle_data(self, pt):
         """Add information about the particle to the dataset"""
         self.frequencies.append(pt.f)
@@ -89,11 +83,6 @@ class GeneralData(Data):
         self.travel_times.append(flight.travel_time)
         self.mean_free_paths.append(flight.mean_free_path)
         self.thermal_conductivity.append(flight.thermal_conductivity)
-        self.interfaces_angles.extend(flight.interfaces_angles)
-        self.interfaces_transmission_factor.extend(flight.interfaces_transmission_factor)
-        self.interfaces_wavelength.extend(flight.interfaces_wavelength)
-        self.interfaces_frequency.extend(flight.interfaces_frequency)
-        self.interfaces_mode.extend(flight.interfaces_mode)
 
 
     def write_into_files(self):
@@ -105,20 +94,15 @@ class GeneralData(Data):
             np.savetxt("Data/All free paths.csv", self.free_paths, fmt='%2.4e', header="L [m]", encoding='utf-8')
         np.savetxt("Data/All initial frequencies.csv", self.frequencies, fmt='%2.4e', header="f [Hz]", encoding='utf-8')
         np.savetxt("Data/All exit angles.csv", self.exit_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
-        np.savetxt("Data/All hole diffuse scattering angles.csv", self.hole_diff_scattering_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
-        np.savetxt("Data/All hole specular scattering angles.csv", self.hole_spec_scattering_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
+        if cf.holes:
+            np.savetxt("Data/All hole diffuse scattering angles.csv", self.hole_diff_scattering_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
+            np.savetxt("Data/All hole specular scattering angles.csv", self.hole_spec_scattering_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')
         np.savetxt("Data/All group velocities.csv", self.group_velocities, fmt='%.4f', header="Vg [m//s]", encoding='utf-8')
         np.savetxt("Data/All travel times.csv", self.travel_times, fmt='%2.4e', header="Travel time [s]", encoding='utf-8')
         np.savetxt("Data/All mean free paths.csv", self.mean_free_paths, fmt='%2.4e', header="MFPs [m]", encoding='utf-8')
         np.savetxt("Data/All thermal conductivities.csv", self.thermal_conductivity, fmt='%2.4e', header="K [W/mK]", encoding='utf-8')
         np.savetxt("Data/All initial energies.csv", self.initial_energies, fmt='%2.4e', header="Energy [J]", encoding='utf-8')
-        np.savetxt("Data/All interfaces angles.csv", self.interfaces_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
-        np.savetxt("Data/All interfaces transmission factor.csv", self.interfaces_transmission_factor, fmt='%2.4e', header="Transmission factor [%]", encoding='utf-8')
-        np.savetxt("Data/All interfaces wavelength.csv", self.interfaces_wavelength, fmt='%.18f', header="Interfaces wavelength [m]", encoding='utf-8')
-        np.savetxt("Data/All interfaces frequency.csv", self.interfaces_frequency, fmt='%.18f', header="Interfaces frequency [THz]", encoding='utf-8')
-        np.savetxt("Data/All interfaces mode.csv", self.interfaces_mode, fmt='%d', header="Interfaces mode", 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 {
@@ -133,11 +117,6 @@ class GeneralData(Data):
             'mean_free_paths': self.mean_free_paths,
             'thermal_conductivity': self.thermal_conductivity,
             'initial_energies': self.initial_energies,
-            'interfaces_angles': self.interfaces_angles,
-            'interfaces_transmission_factor': self.interfaces_transmission_factor,
-            'interfaces_wavelength': self.interfaces_wavelength,
-            'interfaces_frequency': self.interfaces_frequency,
-            'interfaces_mode': self.interfaces_mode,
         }
 
 
@@ -298,11 +277,9 @@ class SegmentData(Data):
 
     def record_time_in_segment(self, coordinate):
         """Record how long particle stays in different segments"""
-        for segment_number in range(cf.number_of_length_segments):
-            segment_beginning = segment_number * (cf.length / cf.number_of_length_segments)
-            segment_end = (segment_number + 1)*(cf.length / cf.number_of_length_segments)
-            if segment_beginning <= coordinate < segment_end:
-                self.time_spent[segment_number] += cf.timestep * 1e6
+        segment = int(coordinate // (cf.length / cf.number_of_length_segments))
+        if 0 <= segment < cf.number_of_length_segments:
+            self.time_spent[segment] += cf.timestep * 1e9
 
     def write_into_files(self):
         """Write data into files"""

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/default_config.py

@@ -25,13 +25,16 @@ NUMBER_OF_STABILIZATION_TIMEFRAMES = 5
 
 # Electron parameters [eV]
 IS_CARRIER_ELECTRON              = True
-ENERGY_UPPER_BOUND               = 6*k*T / electron_volt
+ENERGY_UPPER_BOUND               = 350e-3
 ENERGY_LOWER_BOUND               = 0
 ENERGY_STEP                      = 5e-3
 
 ELECTRON_MFP                     = 10e-9 # [m]
 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.2  # [eV] upper end of post-processing Fermi level sweep
+
 
 # Animation:
 OUTPUT_PATH_ANIMATION            = False

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/electron.py

@@ -1,6 +1,6 @@
 """This module provides electron class which generates and moves an electron"""
 
-from random import choice
+from random import choice, random
 from scipy.constants import h, electron_volt
 from freepaths.config import cf
 from freepaths.particle import Particle
@@ -72,6 +72,4 @@ class Electron(Particle):
         Considering only elasctic scattering between electrons and phonons and thus a constant MFP.
         """
         mfp = cf.electron_mfp
-        self.time_of_internal_scattering = mfp / self.speed
-
-        # self.time_of_internal_scattering = -np.log(random()) * (mfp/self.speed)
+        self.time_of_internal_scattering = -np.log(random()) * (mfp / self.speed)

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/flight.py

@@ -43,12 +43,6 @@ class Flight:
         self.hole_diff_scattering_angles = []
         self.hole_spec_scattering_angles = []
         self.thermal_conductivity = 0.0
-        self.interfaces_angles = []
-        self.interfaces_transmission_factor = []
-        self.interfaces_wavelength = []
-        self.interfaces_frequency = []
-        self.interfaces_mode = []
-
     @property
     def mean_free_path(self):
         """Mean value of all free flights"""
@@ -74,26 +68,6 @@ class Flight:
         """Save angle of specular scattering from the hole"""
         self.hole_spec_scattering_angles.append(angle)
 
-    def save_interfaces_angles(self, angle):
-        """Save a transmission event angle"""
-        self.interfaces_angles.append(angle)
-
-    def save_interfaces_transmission_factor(self, alpha_total):
-        """Save a transmission event"""
-        self.interfaces_transmission_factor.append(alpha_total)
-
-    def save_interfaces_wavelength(self):
-        """Save a wavelength event"""
-        self.interfaces_wavelength.append(self.particle.wavelength)
-
-    def save_interfaces_frequency(self):
-        """Save a frequency event"""
-        self.interfaces_frequency.append(self.particle.f)
-
-    def save_interfaces_mode (self):
-        """Save mode"""
-        self.interfaces_mode.append(self.particle.branch_number)
-
     def restart(self):
         """Restart the flight after a scattering event"""
         self.time_since_previous_scattering = 0.0

freepaths-2.3.3/freepaths/main_mfp_sampling.py

@@ -0,0 +1,195 @@
+"""Module to run thermal conductivity calculations by integrating the phonon dispersion"""
+
+import os
+import numpy as np
+import sys
+import time
+import shutil
+import scipy
+import math
+import logging
+import signal
+import traceback
+import multiprocessing
+from colorama import Fore, Style
+
+# Modules:
+from freepaths.animation import create_animation
+from freepaths.config import cf
+from freepaths.run_particle import run_particle
+from freepaths.phonon import Phonon
+from freepaths.flight import Flight
+from freepaths.particle_types import ParticleType
+from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
+from freepaths.materials import Si, SiC, Graphite, SiGe
+from freepaths.maps import ScatteringMap
+from freepaths.progress import Progress
+from freepaths.output_info import output_general_information, output_scattering_information, output_parameter_warnings
+from freepaths.output_plots import plot_data
+
+
+def _branch_worker(branch_number, shared_list):
+    """Entry point for each worker process. Catches exceptions so they are logged
+    rather than silently swallowed by the multiprocessing machinery."""
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    try:
+        _run_branch(branch_number, shared_list)
+    except Exception:
+        logging.exception("Branch worker %d crashed", branch_number)
+
+
+def _run_branch(branch_number, shared_list):
+    """Run all phonons for one polarization branch and push results to shared_list.
+
+    Each call processes NUMBER_OF_PARTICLES phonons sampled uniformly across the
+    dispersion of the given branch.  The k-vector integration weight (d_k_vector)
+    is the width of the k-space interval assigned to each phonon, so the sum of
+    flight.thermal_conductivity over all phonons approximates the branch integral
+    in Phys. Rev. 132 2461 (1963).
+
+    Branch 0 also drives the shared progress bar; the other two run silently.
+    Results are appended to shared_list as a dict of dump_data() payloads so that
+    the main process can merge them with the standard read_data() mechanism.
+    """
+
+    # 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
+
+    # Local data structures — merged into the global ones after all workers finish:
+    scatter_stats = ScatteringData()
+    general_stats = GeneralData()
+    segment_stats = SegmentData()
+    places_stats = TriangleScatteringData()
+    path_stats = PathData()
+    scatter_maps = ScatteringMap()
+
+    total_thermal_conductivity = 0.0
+    progress = Progress() if branch_number == 0 else None
+
+    for index in range(cf.number_of_particles):
+        if progress:
+            progress.render(index, cf.number_of_particles)
+
+        # Mid-point k-vector and integration weight for this phonon:
+        k_vector = (material.dispersion[index + 1, 0] + material.dispersion[index, 0]) / 2
+        d_k_vector = material.dispersion[index + 1, 0] - material.dispersion[index, 0]
+
+        # Initialise phonon at this k-point and run it through the geometry:
+        phonon = Phonon(material, branch_number, index)
+        flight = Flight(phonon)
+        run_particle(phonon, flight, scatter_stats, places_stats, segment_stats, None, scatter_maps, material)
+
+        # Mode heat capacity (Ref. PRB 88 155318, 2013):
+        omega = 2 * math.pi * phonon.f
+        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):
+        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
+        total_thermal_conductivity += flight.thermal_conductivity
+
+        general_stats.save_particle_data(phonon)
+        general_stats.save_flight_data(flight)
+
+        if index < cf.output_trajectories_of_first:
+            path_stats.save_particle_path(flight)
+
+    # Push this branch's results to the shared list for the main process to collect:
+    shared_list.append({
+        'total_thermal_conductivity': total_thermal_conductivity,
+        '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(),
+    })
+
+
+def main(input_file, particle_type):
+    """Integrate the phonon dispersion over all three branches in parallel to get
+    the bulk thermal conductivity via the MFP-sampling method."""
+
+    print(f'Mean free path sampling of {Fore.GREEN}{cf.output_folder_name}{Style.RESET_ALL}')
+    start_time = time.time()
+
+    # Spawn one worker process per polarization branch (LA + 2×TA).
+    # All three run concurrently; branch 0 reports progress to stdout:
+    manager = multiprocessing.Manager()
+    shared_list = manager.list()
+
+    processes = [
+        multiprocessing.Process(target=_branch_worker, args=(branch_number, shared_list))
+        for branch_number in range(3)
+    ]
+    for process in processes:
+        process.start()
+    try:
+        for process in processes:
+            process.join()
+    except KeyboardInterrupt:
+        for process in processes:
+            process.terminate()
+        raise
+
+    # Merge per-branch results into single data structures:
+    scatter_stats = ScatteringData()
+    general_stats = GeneralData()
+    segment_stats = SegmentData()
+    places_stats = TriangleScatteringData()
+    path_stats = PathData()
+    scatter_maps = ScatteringMap()
+    total_thermal_conductivity = 0.0
+
+    for result in shared_list:
+        total_thermal_conductivity += result['total_thermal_conductivity']
+        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'])
+
+    # Create the output folder and copy input file:
+    if not os.path.exists("Results/" + cf.output_folder_name):
+        os.makedirs("Results/" + cf.output_folder_name)
+        os.makedirs("Results/" + cf.output_folder_name + '/Data')
+    if input_file:
+        shutil.copy(input_file, "Results/" + cf.output_folder_name)
+    os.chdir("Results/" + cf.output_folder_name)
+
+    # Save data and generate plots:
+    general_stats.write_into_files()
+    scatter_stats.write_into_files()
+    segment_stats.write_into_files()
+    if cf.output_scattering_map:
+        scatter_maps.write_into_files()
+    path_stats.write_into_files()
+
+    if cf.output_path_animation:
+        create_animation()
+
+    np.savetxt("Data/Thermal conductivity from MFP.csv", np.array([total_thermal_conductivity]), fmt='%2.4e', header="K [W/mK]", encoding='utf-8')
+
+    sys.stdout.write("\rAnalyzing the data...")
+    plot_data(particle_type, cf, mfp_sampling=True)
+
+    output_general_information(start_time)
+    output_scattering_information(scatter_stats)
+    output_parameter_warnings(ParticleType.PHONON)
+    sys.stdout.write(f'\rSee the results in {Fore.GREEN}Results/{cf.output_folder_name}{Style.RESET_ALL}\n')
+    sys.stdout.write(f"\rThermal conductivity = {Fore.GREEN}{total_thermal_conductivity:.5f}{Style.RESET_ALL} W/m·K\n")
+    sys.stdout.write(f"\r{Fore.BLUE}Thank you for using FreePATHS{Style.RESET_ALL}\n\n")

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/main_tracing.py

@@ -280,10 +280,12 @@ def main(input_file, particle_type):
     sys.stdout.write("\rSaving raw data...")
     general_stats.write_into_files()
     scatter_stats.write_into_files()
-    places_stats.write_into_files()
+    if cf.holes:
+        places_stats.write_into_files()
     segment_stats.write_into_files()
     thermal_maps.write_into_files()
-    scatter_maps.write_into_files()
+    if cf.output_scattering_map:
+        scatter_maps.write_into_files()
     path_stats.write_into_files()
     if particle_type is ParticleType.ELECTRON:
         electron_computations.write_into_file()

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/maps.py

@@ -119,6 +119,8 @@ class ThermalMaps(Maps):
 
     def calculate_pixel_volumes(self, number_of_pixels_x, number_of_pixels_y):
         """Calculate a map showing if the pixel contains material (1) or a hole (0)"""
+        if not cf.holes:
+            return np.ones((number_of_pixels_y, number_of_pixels_x))
         pixel_volume_ratios = np.zeros((number_of_pixels_y, number_of_pixels_x))
         for x_index in range(number_of_pixels_x):
             for y_index in range(number_of_pixels_y):

{freepaths-2.3.2 → freepaths-2.3.3}/freepaths/materials.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 import numpy as np
-from scipy.constants import electron_volt, electron_mass
+from scipy.constants import electron_volt, electron_mass, k as k_B, h as h_planck
 
 
 class Material(ABC):
@@ -74,6 +74,16 @@ class Si(Material):
             coeffs = above_50K_coeffs
         self.heat_capacity = np.polyval(coeffs, self.temp)
 
+    # --- Impurity scattering via Matthiessen's rule (disabled; re-enable when ready) ---
+    # Phonon-limited electron MFP at 300K, calibrated to match lightly doped Si literature
+    # phonon_limited_electron_mfp = 10e-9  # [m]
+    # Caughey-Thomas ionized-impurity parameters for electrons, Masetti et al. (1983)
+    # _ct_mu_max = 1417e-4   # [m²/V·s]
+    # _ct_mu_min = 52.2e-4   # [m²/V·s]
+    # _ct_n_ref  = 9.68e22   # [m⁻³]  (= 9.68e16 cm⁻³)
+    # _ct_alpha  = 0.680
+    # ---------------------------------------------------------------------------------
+
     def assign_electrical_properties(self, fermi_level):
         """Assign differents electrical properties to the material."""
         self.effective_electron_dos_mass = 1.18 * electron_mass # [kg] at 300K for pure Si, supposed constant for all temperatures (~1-5% error)
@@ -87,6 +97,17 @@ class Si(Material):
         else:
             self.fermi_level = -0.037 * electron_volt # [J]
 
+    # def carrier_density(self):
+    #     """Electron carrier density from Fermi level using Boltzmann approximation [m⁻³]"""
+    #     nc = 2 * (2 * np.pi * self.effective_electron_dos_mass * k_B * self.temp / h_planck**2) ** 1.5
+    #     return nc * np.exp(self.fermi_level / (k_B * self.temp))
+
+    # def effective_electron_mfp(self):
+    #     """Effective electron MFP combining phonon and impurity scattering via Matthiessen's rule"""
+    #     n = self.carrier_density()
+    #     mu = self._ct_mu_min + (self._ct_mu_max - self._ct_mu_min) / (1 + (n / self._ct_n_ref) ** self._ct_alpha)
+    #     return self.phonon_limited_electron_mfp * mu / self._ct_mu_max
+
 
 class Vacuum:
     def __init__(self, temp=300):
@@ -110,7 +131,18 @@ class SiC:
     Heat capacity - Collins et al. Journal of Applied Physics 68, 6510 (1990)
     """
 
-    def __init__(self, temp, num_points=1000):
+    # --- Impurity scattering via Matthiessen's rule (disabled; re-enable when ready) ---
+    # 4H-SiC electrical properties:
+    # Electron effective masses - Ioffe database / Persson & Lindefelt, PRB 54, 10257 (1996)
+    # CT parameters - Roschke & Schwierz, IEEE Trans. Electron Devices 48, 1442 (2001)
+    # phonon_limited_electron_mfp = 7e-9  # [m] estimate, needs experimental calibration
+    # _ct_mu_max = 947e-4    # [m²/V·s]
+    # _ct_mu_min = 40e-4     # [m²/V·s]
+    # _ct_n_ref  = 2.0e23    # [m⁻³]  (= 2.0e17 cm⁻³)
+    # _ct_alpha  = 0.61
+    # ---------------------------------------------------------------------------------
+
+    def __init__(self, temp, num_points=1000, fermi_level=None):
         self.name = "SiC"
         self.density = 3215         # [kg/m^3]
         self.default_speed = 6500   # [m/s] Need to change this probably...
@@ -118,6 +150,27 @@ class SiC:
         self.assign_phonon_dispersion(num_points)
         self.assign_heat_capacity()
 
+    # def assign_electrical_properties(self, fermi_level):
+    #     """Assign electrical properties for 4H-SiC"""
+    #     self.effective_electron_dos_mass = 1.0 * electron_mass   # [kg] 4H-SiC, Ioffe
+    #     self.effective_electron_mass = 0.36 * electron_mass       # [kg] conductivity mass
+    #     self.effective_hole_dos_mass = 0.6 * electron_mass
+    #     self.effective_hole_mass = 0.6 * electron_mass
+    #     self.fermi_level = fermi_level  # None = no CT correction applied
+
+    # def carrier_density(self):
+    #     """Electron carrier density from Fermi level using Boltzmann approximation [m⁻³]"""
+    #     nc = 2 * (2 * np.pi * self.effective_electron_dos_mass * k_B * self.temp / h_planck**2) ** 1.5
+    #     return nc * np.exp(self.fermi_level / (k_B * self.temp))
+
+    # def effective_electron_mfp(self):
+    #     """Effective electron MFP combining phonon and impurity scattering via Matthiessen's rule"""
+    #     if self.fermi_level is None:
+    #         return self.phonon_limited_electron_mfp
+    #     n = self.carrier_density()
+    #     mu = self._ct_mu_min + (self._ct_mu_max - self._ct_mu_min) / (1 + (n / self._ct_n_ref) ** self._ct_alpha)
+    #     return self.phonon_limited_electron_mfp * mu / self._ct_mu_max
+
     def assign_phonon_dispersion(self, num_points):
         """Assign phonon dispersion"""
 
@@ -220,6 +273,13 @@ class SiGe(Material):
     Effective masses – linearly interpolated between Si and Ge at x=0.2 (Schaffler, 2001)
     """
 
+    # --- Impurity scattering via Matthiessen's rule (disabled; re-enable when ready) ---
+    # phonon_limited_electron_mfp = 7e-9  # [m] estimate; alloy scattering reduces from pure Si
+    # def effective_electron_mfp(self):
+    #     """Phonon-limited only — CT params not established for SiGe alloy"""
+    #     return self.phonon_limited_electron_mfp
+    # ---------------------------------------------------------------------------------
+
     def __init__(self, temp, num_points=1000):
         self.name = "SiGe"
         self.default_speed = 3700   # [m/s] – average LA/TA
@@ -275,6 +335,13 @@ class Diamond(Material):
     Dispersion - Ref. PRB 58 12899 (1998)
     """
 
+    # --- Impurity scattering via Matthiessen's rule (disabled; re-enable when ready) ---
+    # phonon_limited_electron_mfp = 20e-9  # [m] estimate; CT params for n-type diamond not established
+    # def effective_electron_mfp(self):
+    #     """Phonon-limited only — CT params for n-type diamond not established"""
+    #     return self.phonon_limited_electron_mfp
+    # ---------------------------------------------------------------------------------
+
     def __init__(self, temp, num_points=1000):
         self.name = "Diamond"
         self.density = 3500         # [kg/m^3]