freepaths 2.3.2__tar.gz → 2.3.4__tar.gz

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

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

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

@@ -5,9 +5,9 @@ import argparse
 import colorama
 from colorama import Fore, Style
 
-from freepaths.particle_types import ParticleType
+from freepaths.options import SimulationMode
 
-__version__ = "2.3.2"
+__version__ = "2.3.4"
 
 colorama.init()
 
@@ -45,15 +45,15 @@ def run():
     try:
         if args.sampling:
             import freepaths.main_mfp_sampling
-            freepaths.main_mfp_sampling.main(args.input_file, ParticleType.PHONON)
+            freepaths.main_mfp_sampling.main(args.input_file, SimulationMode.PHONON_MFP_SAMPLING)
 
         elif args.electron:
             import freepaths.main_tracing
-            freepaths.main_tracing.main(args.input_file, ParticleType.ELECTRON)
+            freepaths.main_tracing.main(args.input_file, SimulationMode.ELECTRON)
 
         else:
             import freepaths.main_tracing
-            freepaths.main_tracing.main(args.input_file, ParticleType.PHONON)
+            freepaths.main_tracing.main(args.input_file, SimulationMode.PHONON_TRACING)
 
     except KeyboardInterrupt:
         print(f"\n{Fore.RED}Simulation interrupted by user.{Style.RESET_ALL}")

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

@@ -3,6 +3,7 @@ Module that reads the user input file, provides default values,
 checks the validity of the parameters and converts the variables into enums
 """
 
+import os
 import sys
 import argparse
 import logging
@@ -32,8 +33,11 @@ args = parser.parse_args()
 
 # If a file is provided, overwrite the default values:
 if args.input_file:
+    input_path = args.input_file
+    if not os.path.isfile(input_path) and not input_path.endswith('.py') and os.path.isfile(input_path + '.py'):
+        input_path = input_path + '.py'
     try:
-        exec(open(args.input_file, encoding='utf-8').read(), globals())
+        exec(open(input_path, encoding='utf-8').read(), globals())
     except FileNotFoundError:
         logging.error("Input file does not exist. Check if you are in the right folder and the file name is correct.")
         sys.exit()
@@ -69,6 +73,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.4}/freepaths/data.py

@@ -66,59 +66,53 @@ 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):
+    def save_particle_data(self, pt, mode=None):
         """Add information about the particle to the dataset"""
-        self.frequencies.append(pt.f)
-        self.group_velocities.append(pt.speed)
-        self.initial_energies.append(pt.energy)
-
-    def save_flight_data(self, flight):
+        from freepaths.options import SimulationMode
+        if mode is SimulationMode.ELECTRON:
+            self.initial_energies.append(pt.energy)
+        else:
+            self.frequencies.append(pt.f)
+            self.group_velocities.append(pt.speed)
+
+    def save_flight_data(self, flight, mode=None):
         """Add information about the particle flight to the dataset"""
+        from freepaths.options import SimulationMode
         if not cf.low_memory_usage:
             self.free_paths.extend(flight.free_paths)
-        self.initial_angles.append(flight.initial_theta)
-        self.exit_angles.append(flight.exit_theta)
-        self.hole_diff_scattering_angles.extend(flight.hole_diff_scattering_angles)
-        self.hole_spec_scattering_angles.extend(flight.hole_spec_scattering_angles)
+        if mode is SimulationMode.PHONON_TRACING:
+            self.initial_angles.append(flight.initial_theta)
+            self.exit_angles.append(flight.exit_theta)
+            self.hole_diff_scattering_angles.extend(flight.hole_diff_scattering_angles)
+            self.hole_spec_scattering_angles.extend(flight.hole_spec_scattering_angles)
         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)
-
+        if mode is SimulationMode.PHONON_MFP_SAMPLING:
+            self.thermal_conductivity.append(flight.thermal_conductivity)
 
-    def write_into_files(self):
+    def write_into_files(self, mode=None):
         import os
+        from freepaths.options import SimulationMode
         if not os.path.exists("Data"):
             os.makedirs("Data")
         """Write all the data into files"""
         if not cf.low_memory_usage:
             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')
-        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')
+        if mode is SimulationMode.ELECTRON:
+            np.savetxt("Data/All initial energies.csv", self.initial_energies, fmt='%2.4e', header="Energy [J]", encoding='utf-8')
+        else:
+            np.savetxt("Data/All initial frequencies.csv", self.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')
+        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')
+            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 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')
-
+        if mode is SimulationMode.PHONON_MFP_SAMPLING:
+            np.savetxt("Data/All thermal conductivities.csv", self.thermal_conductivity, fmt='%2.4e', header="K [W/mK]", 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 +127,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 +287,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.4}/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.4}/freepaths/electron.py

@@ -1,10 +1,10 @@
 """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
-from freepaths.particle_types import ParticleType
+from freepaths.options import ParticleType
 
 import numpy as np
 
@@ -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.4}/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.4/freepaths/main_mfp_sampling.py

@@ -0,0 +1,231 @@
+"""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.options import SimulationMode
+from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
+from freepaths.materials import Si, SiC, Graphite, SiGe
+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
+
+
+def display_all_progress(shared_progress, finished_branches, branch_names):
+    """Render a live progress percentage for each branch on its own line."""
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    n = len(branch_names)
+    width = max(len(name) for name in branch_names)
+    try:
+        for name in branch_names:
+            sys.stdout.write(f'  {name.ljust(width)}:   0%\n')
+        sys.stdout.flush()
+        while True:
+            sys.stdout.write(f'\033[{n}A')
+            for i, name in enumerate(branch_names):
+                sys.stdout.write(f'\r  {name.ljust(width)}: {shared_progress[i]:3d}%\n')
+            sys.stdout.flush()
+            if finished_branches.value == n:
+                break
+            time.sleep(0.1)
+    except Exception:
+        pass
+
+
+def _branch_worker(branch_number, shared_list, finished_branches, shared_progress):
+    """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, shared_progress)
+        shared_progress[branch_number] = 100
+        finished_branches.value += 1
+    except Exception:
+        logging.exception("Branch worker %d crashed", branch_number)
+
+
+def _run_branch(branch_number, shared_list, shared_progress):
+    """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 2 (TA) 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
+    last_pct = -1
+
+    for index in range(cf.number_of_particles):
+        pct = 100 * index // cf.number_of_particles
+        if pct > last_pct:
+            shared_progress[branch_number] = pct
+            last_pct = pct
+
+        # 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, SimulationMode.PHONON_MFP_SAMPLING)
+        general_stats.save_flight_data(flight, SimulationMode.PHONON_MFP_SAMPLING)
+
+        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, mode: SimulationMode):
+    """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()
+
+    branch_names = get_media_class(cf.media).branch_names
+    n_branches = len(branch_names)
+
+    # Spawn one worker process per polarization branch, all running concurrently:
+    manager = multiprocessing.Manager()
+    shared_list = manager.list()
+    finished_branches = manager.Value('i', 0)
+    shared_progress = manager.list([0] * n_branches)
+
+    processes = [
+        multiprocessing.Process(target=_branch_worker, args=(branch_number, shared_list, finished_branches, shared_progress))
+        for branch_number in range(n_branches - 1, -1, -1)
+    ]
+    for process in processes:
+        process.start()
+
+    display_process = multiprocessing.Process(target=display_all_progress, args=(shared_progress, finished_branches, branch_names))
+    display_process.start()
+
+    try:
+        for process in processes:
+            process.join()
+    except KeyboardInterrupt:
+        for process in processes:
+            process.terminate()
+        raise
+
+    display_process.join(timeout=3)
+    display_process.terminate()
+
+    # 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(mode)
+    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(mode, cf)
+
+    output_general_information(start_time)
+    output_scattering_information(scatter_stats)
+    output_parameter_warnings(mode)
+    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")