freepaths 1.1__0-py3-none-any.whl

freepaths/__main__.py

@@ -0,0 +1,30 @@
+"""FreePATHS - Free Phonon and THermal Simulator"""
+
+import argparse
+
+import freepaths.main_tracing
+import freepaths.main_mfp_sampling
+
+__version__ = "1.1.0"
+
+# Parse user arguments:
+parser = argparse.ArgumentParser(
+                prog = 'FreePATHS',
+                description = 'Monte Carlo simulator',
+                epilog = 'For more information, visit: https://github.com/anufrievroman/freepaths'
+                )
+parser.add_argument('input_file', nargs='?', default=None, help='The input file')
+parser.add_argument("-s", "--sampling", help="Run in MFP sampling mode", action="store_true")
+args = parser.parse_args()
+
+
+def run():
+    """Run the program depending on the mode"""
+    if args.sampling:
+        freepaths.main_mfp_sampling.main(args.input_file)
+    else:
+        freepaths.main_tracing.main(args.input_file)
+
+
+if __name__ == "__main__":
+    run()

freepaths/animation.py

@@ -0,0 +1,64 @@
+"""Module that creates animations from recorded phonon paths"""
+
+import sys
+import os
+import shutil
+import imageio
+import numpy as np
+import matplotlib.pyplot as plt
+
+from freepaths.config import cf
+
+
+def generate_frames_xy():
+    """Generate animation frames with phonon paths"""
+
+    data = np.genfromtxt("Data/Phonon paths.csv",
+                         unpack=False,
+                         delimiter=',',
+                         skip_header=1,
+                         encoding='utf-8')
+
+    plt.rcParams['xtick.direction'] = "out"
+    plt.rcParams['ytick.direction'] = "out"
+    cmap = plt.get_cmap("tab10")
+
+    # Create XY plots for each step of each phonon:
+    frame_number = 0
+    for phonon_num in range(cf.phonons_in_animation):
+        x_coords = np.trim_zeros(data[:, 3 * phonon_num], trim='b')
+        y_coords = np.trim_zeros(data[:, 3 * phonon_num + 1], trim='b')
+        steps = np.shape(x_coords)[0]
+        for step in range(1, steps):
+            fig, ax = plt.subplots()
+            ax.plot(x_coords[:step], y_coords[:step], color=cmap(phonon_num), linewidth=0.5)
+            ax.set_xlabel('X (μm)', fontsize=12)
+            ax.set_ylabel('Y (μm)', fontsize=12)
+            ax.set_xlim([-0.55*cf.width*1e6, 0.55*cf.width*1e6])
+            ax.set_ylim([0, cf.length*1e6])
+            ax.set_aspect('equal')
+            fig.savefig(f"Frames/frame_{frame_number:0>6}.png", dpi=600, bbox_inches="tight")
+            plt.close(fig)
+            frame_number += 1
+
+
+def generate_animation_xy():
+    """Generate animation of phonon path in XY plane"""
+    images = []
+    filenames = os.listdir("Frames/")
+    for filename in filenames:
+        images.append(imageio.imread(f"Frames/{filename}"))
+    imageio.mimsave("Animated paths XY.gif", images)
+
+
+def delete_frames():
+    """Delete frames after creating the animation"""
+    folder_path = "Frames/"
+    shutil.rmtree(folder_path)
+
+
+def create_animation():
+    """Main function that creates the animation"""
+    generate_frames_xy()
+    generate_animation_xy()
+    delete_frames()

freepaths/config.py

@@ -0,0 +1,156 @@
+"""Module that reads the user input file, privides default values, and converts the variables into enums"""
+
+import sys
+import argparse
+
+from freepaths.options import Materials, Distributions, Positions
+
+# Import a default input file:
+from freepaths.default_config import *
+
+
+# Parse user arguments:
+WEBSITE = 'https://github.com/anufrievroman/freepaths'
+parser = argparse.ArgumentParser(prog='FreePATHS', description='Monte Carlo simulator',
+                                 epilog=f'For more information, visit: {WEBSITE}')
+parser.add_argument('input_file', nargs='?', default=None, help='The input file')
+parser.add_argument("-s", "--sampling", help="Run in MFP sampling mode", action="store_true")
+args = parser.parse_args()
+
+
+# If a file is provided, overwrite the default values:
+if args.input_file:
+    exec(open(args.input_file).read(), globals())
+else:
+    print("You didn't provide any input file, so we run a demo simulation:\n")
+
+
+class Config:
+    """Class that contains all the settings for the simulation"""
+
+    def __init__(self):
+        """Initiate all the parameters from global variables"""
+
+        # General parameters:
+        self.output_folder_name = OUTPUT_FOLDER_NAME
+        self.number_of_phonons = NUMBER_OF_PHONONS
+        self.number_of_timesteps = NUMBER_OF_TIMESTEPS
+        self.number_of_nodes = NUMBER_OF_NODES
+        self.timestep = TIMESTEP
+        self.temp = T
+        self.plots_in_terminal = PLOTS_IN_TERMINAL
+        self.output_scattering_map = OUTPUT_SCATTERING_MAP
+        self.output_raw_thermal_map = OUTPUT_RAW_THERMAL_MAP
+        self.output_trajectories_of_first = OUTPUT_TRAJECTORIES_OF_FIRST
+        self.output_path_animation = OUTPUT_PATH_ANIMATION
+        self.phonons_in_animation = PHONONS_IN_ANIMATION
+        self.number_of_length_segments = NUMBER_OF_LENGTH_SEGMENTS
+        self.hot_side_angle_distribution = HOT_SIDE_ANGLE_DISTRIBUTION
+
+        # Map & profiles parameters:
+        self.number_of_pixels_x = NUMBER_OF_PIXELS_X
+        self.number_of_pixels_y = NUMBER_OF_PIXELS_Y
+        self.number_of_timeframes = NUMBER_OF_TIMEFRAMES
+
+        # Material parameters:
+        self.media = MEDIA
+        self.specific_heat_capacity = SPECIFIC_HEAT_CAPACITY
+
+        # Internal scattering:
+        self.include_internal_scattering = INCLUDE_INTERNAL_SCATTERING
+        self.use_gray_approximation_mfp = USE_GRAY_APPROXIMATION_MFP
+        self.gray_approximation_mfp = GRAY_APPROXIMATION_MFP
+
+        # System dimensions:
+        self.thickness = THICKNESS
+        self.width = WIDTH
+        self.length = LENGTH
+
+        # Hot and cold sides:
+        self.frequency_detector_size = FREQUENCY_DETECTOR_SIZE
+        self.cold_side_position = COLD_SIDE_POSITION
+        self.hot_side_x = HOT_SIDE_X
+        self.hot_side_y = HOT_SIDE_Y
+        self.hot_side_width_x = HOT_SIDE_WIDTH_X
+        self.hot_side_width_y = HOT_SIDE_WIDTH_Y
+
+        # Roughness:
+        self.side_wall_roughness = SIDE_WALL_ROUGHNESS
+        self.hole_roughness = HOLE_ROUGHNESS
+        self.pillar_roughness = PILLAR_ROUGHNESS
+        self.top_roughness = TOP_ROUGHNESS
+        self.bottom_roughness = BOTTOM_ROUGHNESS
+        self.pillar_top_roughness = PILLAR_TOP_ROUGHNESS
+
+        # Parabolic boundary:
+        self.include_top_parabola = INCLUDE_TOP_PARABOLA
+        self.top_parabola_tip = TOP_PARABOLA_TIP
+        self.top_parabola_focus = TOP_PARABOLA_FOCUS
+        self.include_bottom_parabola = INCLUDE_BOTTOM_PARABOLA
+        self.bottom_parabola_tip = BOTTOM_PARABOLA_TIP
+        self.bottom_parabola_focus = BOTTOM_PARABOLA_FOCUS
+
+        # Hole array parameters:
+        self.include_holes = INCLUDE_HOLES
+        self.circular_hole_diameter = CIRCULAR_HOLE_DIAMETER
+        self.rectangular_hole_side_x = RECTANGULAR_HOLE_SIDE_X
+        self.rectangular_hole_side_y = RECTANGULAR_HOLE_SIDE_Y
+        self.period_x = PERIOD_X
+        self.period_y = PERIOD_Y
+
+        # Lattice of holes:
+        self.hole_coordinates = HOLE_COORDINATES
+        self.hole_shapes = HOLE_SHAPES
+
+        # Pillar array parameters [m]
+        self.include_pillars = INCLUDE_PILLARS
+        self.pillar_coordinates = PILLAR_COORDINATES
+        self.pillar_height = PILLAR_HEIGHT
+        self.pillar_wall_angle = PILLAR_WALL_ANGLE
+
+    def convert_to_enums(self):
+        """Convert some user generated parameters into enums"""
+        if self.hot_side_angle_distribution in ["random", "lambert", "directional", "uniform"]:
+            self.hot_side_angle_distribution = Distributions[self.hot_side_angle_distribution.upper()]
+        else:
+            print("ERROR: Parameter HOT_SIDE_ANGLE_DISTRIBUTION is not set correctly.\n")
+            sys.exit()
+
+        if self.media in ["Si", "SiC", "Diamond", "AlN"]:
+            self.media = Materials[self.media]
+        else:
+            print(f"ERROR: Material {self.media} is not in the database.\n")
+            sys.exit()
+
+        if self.cold_side_position in ["top", "top_and_right", "top_and_bottom", "right"]:
+            self.cold_side_position = Positions[self.cold_side_position.upper()]
+        else:
+            print("ERROR: Parameter COLD_SIDE_POSITION is not set correctly.\n")
+            sys.exit()
+
+    def check_parameter_validity(self):
+        """Check if some parameteres are valid"""
+        if self.number_of_phonons < self.output_trajectories_of_first:
+            print("ERROR: Parameter OUTPUT_TRAJECTORIES_OF_FIRST exceeds NUMBER_OF_PHONONS.\n")
+            sys.exit()
+
+        if self.hot_side_y > self.length:
+            print("ERROR: Parameter HOT_SIDE_Y exceeds LENGHT.\n")
+            sys.exit()
+
+        if self.hot_side_y < 0:
+            print("ERROR: Parameter HOT_SIDE_Y is negative.\n")
+            sys.exit()
+
+        if self.hot_side_y - self.hot_side_width_y / 2 < 0:
+            print("ERROR: Parameter HOT_SIDE_WIDTH_Y is too large.\n")
+            sys.exit()
+
+        if self.hot_side_width_x > self.width:
+            print("ERROR: Parameter HOT_SIDE_WIDTH_X exceeds WIDTH.\n")
+            sys.exit()
+
+
+cf = Config()
+cf.convert_to_enums()
+cf.check_parameter_validity()

freepaths/data.py

@@ -0,0 +1,157 @@
+"""Module that controles recording of various data"""
+
+import numpy as np
+
+from freepaths.config import cf
+from freepaths.scattering_types import Scattering
+
+class PathData:
+    """Paths of phonons in space"""
+
+    def __init__(self):
+        """Initialize arrays to save phonon paths"""
+        self.phonon_paths = []
+
+    def save_phonon_path(self, flight):
+        """Save the path to list of all paths"""
+        self.phonon_paths.append(flight.path)
+
+    @property
+    def length_of_longest_path(self):
+        """Calculate the number of points in the longest path"""
+        return max([path.number_of_path_points for path in self.phonon_paths])
+
+    def write_into_files(self):
+        """Write all the path coordinates into a file"""
+        filename = "Data/Phonon paths.csv"
+        data = np.zeros((self.length_of_longest_path, 3*len(self.phonon_paths)))
+        for index, path in enumerate(self.phonon_paths):
+            for point_n, (x, y, z) in enumerate(zip(path.x, path.y, path.z)):
+                data[point_n, 0 + index*3] = x*1e6
+                data[point_n, 1 + index*3] = y*1e6
+                data[point_n, 2 + index*3] = z*1e6
+        np.savetxt(filename, data, fmt='%2.4f', delimiter=",", header="X (μm), Y (μm), Z (μm)", encoding='utf-8')
+
+
+class GeneralData:
+    """General statistics of various phonon properties"""
+
+    def __init__(self):
+        """Initialize arrays for writing various properties"""
+        self.initial_angles = []
+        self.exit_angles = []
+        self.free_paths = []
+        self.free_paths_along_y = []
+        self.frequencies = []
+        self.detected_frequencies = []
+        self.group_velocities = []
+        self.travel_times = []
+
+    def save_phonon_data(self, ph):
+        """Add information about the phonon to the dataset"""
+        self.frequencies.append(ph.f)
+        self.group_velocities.append(ph.speed)
+
+    def save_flight_data(self, flight):
+        """Add information about the phonon flight to the dataset"""
+        self.initial_angles.append(flight.initial_theta)
+        self.exit_angles.append(flight.exit_theta)
+        self.free_paths.extend(flight.free_paths)
+        self.free_paths_along_y.extend(flight.free_paths_along_y)
+        self.travel_times.append(flight.travel_time)
+        self.detected_frequencies.append(flight.detected_frequency)
+
+    def write_into_files(self):
+        """Write all the data into files"""
+        np.savetxt("Data/All free paths.csv", self.free_paths, fmt='%2.4e', delimiter=",", header="L [m]", encoding='utf-8')
+        np.savetxt("Data/All free paths in plane.csv", self.free_paths_along_y, fmt='%2.4e', delimiter=",", header="Ly [m]", encoding='utf-8')
+        np.savetxt("Data/All initial frequencies.csv", self.frequencies, fmt='%2.4e', delimiter=",", header="f [Hz]", encoding='utf-8')
+        np.savetxt("Data/All detected frequencies.csv", self.detected_frequencies, fmt='%2.4e', delimiter=",", header="f [Hz]", encoding='utf-8')
+        np.savetxt("Data/All exit angles.csv", self.exit_angles, fmt='%2.4e', delimiter=",", header="Angle [rad]", encoding='utf-8')
+        np.savetxt("Data/All initial angles.csv", self.initial_angles, fmt='%2.4e', delimiter=",", header="Angle [rad]", encoding='utf-8')
+        np.savetxt("Data/All group velocities.csv", self.group_velocities, fmt='%2.4e', delimiter=",", header="Vg [rad]", encoding='utf-8')
+        np.savetxt("Data/All travel times.csv", self.travel_times, fmt='%2.4e', delimiter=",", header="Travel time [s]", encoding='utf-8')
+
+
+class ScatteringData:
+    """Statistics of phonon scattering events"""
+
+    def __init__(self):
+        """Initialize arrays according to the number of segments"""
+        self.wall_diffuse = np.zeros(cf.number_of_length_segments)
+        self.wall_specular = np.zeros(cf.number_of_length_segments)
+        self.top_diffuse = np.zeros(cf.number_of_length_segments)
+        self.top_specular = np.zeros(cf.number_of_length_segments)
+        self.hole_diffuse = np.zeros(cf.number_of_length_segments)
+        self.hole_specular = np.zeros(cf.number_of_length_segments)
+        self.pillar_diffuse = np.zeros(cf.number_of_length_segments)
+        self.pillar_specular = np.zeros(cf.number_of_length_segments)
+        self.hot_side = np.zeros(cf.number_of_length_segments)
+        self.internal = np.zeros(cf.number_of_length_segments)
+        self.total = np.zeros(cf.number_of_length_segments)
+
+    def save_scattering_events(self, y, scattering_types):
+        """Analyze types of scattering at the current timestep and add it to the statistics"""
+
+        # Calculate in which length segment (starting from zero) we are:
+        segment = int(y // (cf.length / cf.number_of_length_segments))
+        self.total[segment] += 1
+
+        # Scattering on side walls:
+        self.wall_diffuse[segment]  += 1 if scattering_types.walls == Scattering.DIFFUSE else 0
+        self.wall_specular[segment] += 1 if scattering_types.walls == Scattering.SPECULAR else 0
+
+        # Scattering on top and bottom:
+        self.top_diffuse[segment]  += 1 if scattering_types.top_bottom == Scattering.DIFFUSE else 0
+        self.top_specular[segment] += 1 if scattering_types.top_bottom == Scattering.SPECULAR else 0
+
+        # Scattering on holes:
+        self.hole_diffuse[segment]  += 1 if scattering_types.holes == Scattering.DIFFUSE else 0
+        self.hole_specular[segment] += 1 if scattering_types.holes == Scattering.SPECULAR else 0
+
+        # Scattering on pillars:
+        self.pillar_diffuse[segment]  += 1 if scattering_types.pillars == Scattering.DIFFUSE else 0
+        self.pillar_specular[segment] += 1 if scattering_types.pillars == Scattering.SPECULAR else 0
+
+        # Internal scattering and rethermalization on hot side:
+        self.hot_side[segment] += 1 if scattering_types.hot_side == Scattering.DIFFUSE else 0
+        self.internal[segment] += 1 if scattering_types.internal == Scattering.DIFFUSE else 0
+
+    def write_into_files(self):
+        """Write data into a file"""
+        filename = "Data/Scattering events statistics.csv"
+        data = np.vstack((self.wall_diffuse, self.wall_specular, self.top_diffuse, self.top_specular, self.hole_diffuse,
+                        self.hole_specular, self.hot_side, self.internal, self.pillar_diffuse, self.pillar_specular)).T
+        header1 = "Sidewalls diffuse, Sidewalls specular, Top & bottom diffuse, Top & bottom specular, "
+        header2 = "Holes diffuse, Holes specular, Hot side, Internal, Pillars diffuse, Pillars specular"
+        header = header1 + header2
+        np.savetxt(filename, data, fmt='%1.3e', delimiter=",", header=header, encoding='utf-8')
+
+
+class SegmentData:
+    """Statistics of events happening in different segments"""
+
+    def __init__(self):
+        """Initialize arrays according to the number of segments"""
+        self.time_spent = np.zeros(cf.number_of_length_segments)
+
+    @property
+    def segment_coordinates(self):
+        """Calculate coordinates of the centers of each segment"""
+        segment_length = cf.length * 1e6 / cf.number_of_length_segments
+        segments = [(segment_length/2 + i*segment_length) for i in range(cf.number_of_length_segments)]
+        return segments
+
+    def record_time_in_segment(self, coordinate):
+        """Record how long phonon 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
+
+    def write_into_files(self):
+        """Write data into files"""
+        filename = "Data/Time spent in segments.csv"
+        data = np.vstack((self.segment_coordinates, self.time_spent)).T
+        np.savetxt(filename, data, fmt='%1.3e', delimiter=",", header="Y [um], Time [ns]", encoding='utf-8')

freepaths/default_config.py

@@ -0,0 +1,82 @@
+"""Default config file"""
+
+import numpy as np
+
+# General parameters:
+OUTPUT_FOLDER_NAME             = "Si nanowire at 300 K"
+NUMBER_OF_PHONONS              = 500
+NUMBER_OF_TIMESTEPS            = 60000
+NUMBER_OF_NODES                = 400
+TIMESTEP                       = 2e-12
+T                              = 300
+PLOTS_IN_TERMINAL              = False
+OUTPUT_SCATTERING_MAP          = False
+OUTPUT_RAW_THERMAL_MAP         = True
+OUTPUT_TRAJECTORIES_OF_FIRST   = 10
+NUMBER_OF_LENGTH_SEGMENTS      = 10
+HOT_SIDE_ANGLE_DISTRIBUTION    = "random"
+
+# Animation:
+OUTPUT_PATH_ANIMATION          = False
+PHONONS_IN_ANIMATION           = 3
+
+# Map & profiles parameters:
+NUMBER_OF_PIXELS_X             = 100
+NUMBER_OF_PIXELS_Y             = 100
+NUMBER_OF_TIMEFRAMES           = 5
+
+# Material parameters:
+MEDIA                          = "Si"
+SPECIFIC_HEAT_CAPACITY         = 714  # [J/kg/K] for Si at 300 K
+
+# Internal scattering:
+INCLUDE_INTERNAL_SCATTERING    = True
+USE_GRAY_APPROXIMATION_MFP     = False
+GRAY_APPROXIMATION_MFP         = None
+
+# System dimensions [m]:
+THICKNESS                      = 150e-9
+WIDTH                          = 500e-9
+LENGTH                         = 2200e-9
+
+# Hot and cold sides [m]:
+FREQUENCY_DETECTOR_SIZE        = WIDTH
+COLD_SIDE_POSITION             = 'top'
+HOT_SIDE_X                     = 0
+HOT_SIDE_WIDTH_X               = WIDTH
+HOT_SIDE_Y                     = 0
+HOT_SIDE_WIDTH_Y               = 0
+
+# Roughness [m]:
+SIDE_WALL_ROUGHNESS            = 2e-9
+HOLE_ROUGHNESS                 = 2e-9
+PILLAR_ROUGHNESS               = 2e-9
+TOP_ROUGHNESS                  = 0.2e-9
+BOTTOM_ROUGHNESS               = 0.2e-9
+PILLAR_TOP_ROUGHNESS           = 0.2e-9
+
+# Parabolic boundaries:
+INCLUDE_TOP_PARABOLA           = False
+TOP_PARABOLA_TIP               = 1000e-9
+TOP_PARABOLA_FOCUS             = 100e-9
+INCLUDE_BOTTOM_PARABOLA        = False
+BOTTOM_PARABOLA_TIP            = 1000e-9
+BOTTOM_PARABOLA_FOCUS          = 100e-9
+
+# Hole array parameters [m]:
+INCLUDE_HOLES                  = False
+CIRCULAR_HOLE_DIAMETER         = 200e-9
+RECTANGULAR_HOLE_SIDE_X        = 200e-9
+RECTANGULAR_HOLE_SIDE_Y        = 200e-9
+PERIOD_X                       = 300e-9
+PERIOD_Y                       = 300e-9
+
+# Lattice of holes:
+HOLE_COORDINATES = np.zeros((1, 3))
+HOLE_SHAPES = ["circle" for x in range(1)]
+
+# Pillar array parameters [m]
+INCLUDE_PILLARS                = False
+PILLAR_HEIGHT                  = 100e-9
+PILLAR_WALL_ANGLE              = 0.0
+PILLAR_COORDINATES = np.zeros((1, 3))

freepaths/flight.py

@@ -0,0 +1,78 @@
+"""Module that provides phonon flight characteristics"""
+
+from math import cos
+import numpy as np
+
+
+class Path:
+    """Phonon path coordinates"""
+
+    def __init__(self, x_init, y_init, z_init):
+        """Initialize a path"""
+        self.x = np.array([x_init])
+        self.y = np.array([y_init])
+        self.z = np.array([z_init])
+
+    def add_point(self, x_new, y_new, z_new):
+        """Add a point to the phonon path"""
+        self.x = np.append(self.x, x_new)
+        self.y = np.append(self.y, y_new)
+        self.z = np.append(self.z, z_new)
+
+    @property
+    def number_of_path_points(self):
+        """Calculate number of points in the path"""
+        return len(self.x)
+
+
+class Flight:
+    """Phonon flight characteristics"""
+
+    def __init__(self, phonon):
+        """Initialize a phonon flight"""
+        self.phonon = phonon
+        self.initial_frequency = self.phonon.f
+        self.initial_theta = self.phonon.theta
+        self.path = Path(self.phonon.x, self.phonon.y, self.phonon.z)
+        self.exit_theta = 0.0
+        self.detected_frequency = 0.0
+        self.free_path = 0.0
+        self.free_path_along_y = 0.0
+        self.travel_time = 0.0
+        self.time_since_previous_scattering = 0.0
+        self.free_paths = []
+        self.free_paths_along_y = []
+
+    @property
+    def mean_free_path(self):
+        """Mean value of all free flights"""
+        return sum(self.free_paths)/len(self.free_paths)
+
+    def add_point_to_path(self):
+        """Add a scattering point to the path"""
+        self.path.add_point(self.phonon.x, self.phonon.y, self.phonon.z)
+
+    def save_free_paths(self):
+        """Save current free path to the list of free paths"""
+        self.free_paths.append(self.free_path)
+        self.free_paths_along_y.append(self.free_path_along_y)
+
+    def restart(self):
+        """Restart the flight after a scattering event"""
+        self.time_since_previous_scattering = 0.0
+        self.free_path = 0.0
+        self.free_path_along_y = 0.0
+
+    def finish(self, step, timestep, detector_size):
+        """Finish the flight and record final state"""
+        self.exit_theta = self.phonon.theta
+        self.travel_time = step * timestep
+        if abs(self.phonon.x) < detector_size / 2.0:
+            self.detected_frequency = self.phonon.f
+
+    def add_step(self, timestep):
+        """Increase parameters of the flight by length of one step"""
+        step_length = self.phonon.speed * timestep
+        self.free_path += step_length
+        self.free_path_along_y += step_length * abs(cos(self.phonon.phi)) * abs(cos(self.phonon.theta))
+        self.time_since_previous_scattering += timestep

freepaths/main_mfp_sampling.py

@@ -0,0 +1,111 @@
+"""Module to run thermal conductivity calculations by integrating the phonon dispersion"""
+
+import os
+import sys
+import time
+import shutil
+import scipy
+import math
+
+# Modules:
+from freepaths.animation import create_animation
+from freepaths.config import cf
+from freepaths.run_phonon import run_phonon
+from freepaths.phonon import Phonon, Polarization
+from freepaths.flight import Flight
+from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData
+from freepaths.progress import Progress
+from freepaths.materials import Material
+from freepaths.maps import ScatteringMap, ThermalMaps
+from freepaths.output_info import output_general_information, output_scattering_information
+from freepaths.output_plots import plot_data
+
+
+def main(input_file):
+    """This is the main function, which integrates phonon dispersion to get thermal conductivity"""
+
+    print(f'Mean free path sampling of {cf.output_folder_name}')
+    start_time = time.time()
+    progress = Progress()
+
+    # Initiate data structures:
+    material = Material(cf.media, num_points=cf.number_of_phonons+1)
+    scatter_stats = ScatteringData()
+    general_stats = GeneralData()
+    segment_stats = SegmentData()
+    path_stats = PathData()
+    scatter_maps = ScatteringMap()
+    thermal_maps = ThermalMaps()
+
+    thermal_conductivity = 0
+
+    # For each polarization branch:
+    for polarization in [Polarization.LA, Polarization.TA, Polarization.TA]:
+        sys.stdout.write(f"\rIntegrating {polarization.name} branch.\n")
+
+        # For each phonon:
+        for index in range(cf.number_of_phonons):
+
+            # Wave vector:
+            k_vector = (material.dispersion[index+1, 0] + material.dispersion[index, 0]) / 2
+            d_k_vector = (material.dispersion[index+1, 0] - material.dispersion[index, 0])
+
+            # Initiate a phonon and its flight:
+            phonon = Phonon(material, polarization, index)
+            flight = Flight(phonon)
+
+            # Run this phonon through the structure:
+            run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatter_maps, material)
+
+            # Record the properties returned for this phonon:
+            general_stats.save_phonon_data(phonon)
+            general_stats.save_flight_data(flight)
+
+            # Record trajectories of the first N phonons:
+            if index < cf.output_trajectories_of_first:
+                path_stats.save_phonon_path(flight)
+
+            # 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, Ref. Phys. Rev. 132 2461 (1963):
+            relax_time = flight.mean_free_path/phonon.speed
+            thermal_conductivity += (1/(6*(math.pi**2)))*c_p*(phonon.speed**2)*relax_time*(k_vector**2)*d_k_vector
+
+    # Run additional calculations:
+    thermal_maps.calculate_thermal_conductivity()
+
+    # Create the folder if it does not exist and copy input file there:
+    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 into files:
+    general_stats.write_into_files()
+    scatter_stats.write_into_files()
+    segment_stats.write_into_files()
+    thermal_maps.write_into_files()
+    scatter_maps.write_into_files()
+    path_stats.write_into_files()
+
+    # Output general information:
+    output_general_information(start_time)
+    output_scattering_information(scatter_stats)
+
+    # Analyze and plot the data:
+    sys.stdout.write("\rAnalyzing the data...")
+    plot_data()
+
+    # Generate animation of phonon paths:
+    if cf.output_path_animation:
+        sys.stdout.write("\rGenerating path animation...")
+        create_animation()
+
+    sys.stdout.write(f'\rSee the results in "Results/{cf.output_folder_name}" folder.\n')
+    sys.stdout.write(f"\rThermal conductivity = {thermal_conductivity}\n")
+    sys.stdout.write("\rThank you for using FreePATHS.\n")