freepaths 1.9.2__tar.gz → 2.0__tar.gz

{freepaths-1.9.2 → freepaths-2.0}/PKG-INFO

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

{freepaths-1.9.2 → freepaths-2.0}/freepaths/__main__.py

@@ -7,7 +7,7 @@ from colorama import Fore, Style
 import freepaths.main_tracing
 import freepaths.main_mfp_sampling
 
-__version__ = "1.9.2"
+__version__ = "2.0"
 
 colorama.init()
 

{freepaths-1.9.2 → freepaths-2.0}/freepaths/config.py

@@ -29,7 +29,11 @@ args = parser.parse_args()
 
 # If a file is provided, overwrite the default values:
 if args.input_file:
-    exec(open(args.input_file, encoding='utf-8').read(), globals())
+    try:
+        exec(open(args.input_file, 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()
 else:
     logging.warning("You provided no input file, so we will run a demo simulation:")
 

{freepaths-1.9.2 → freepaths-2.0}/freepaths/data.py

@@ -53,6 +53,8 @@ class GeneralData(Data):
         """Initialize arrays for writing various properties"""
         self.initial_angles = []
         self.exit_angles = []
+        self.hole_diff_scattering_angles = []
+        self.hole_spec_scattering_angles = []
         self.free_paths = []
         self.free_paths_along_y = []
         self.frequencies = []
@@ -71,6 +73,8 @@ class GeneralData(Data):
         self.initial_angles.append(flight.initial_theta)
         self.exit_angles.append(flight.exit_theta)
         self.free_paths.extend(flight.free_paths)
+        self.hole_diff_scattering_angles.extend(flight.hole_diff_scattering_angles)
+        self.hole_spec_scattering_angles.extend(flight.hole_spec_scattering_angles)
         self.free_paths_along_y.extend(flight.free_paths_along_y)
         self.travel_times.append(flight.travel_time)
         self.mean_free_paths.append(flight.mean_free_path)
@@ -82,6 +86,8 @@ class GeneralData(Data):
         np.savetxt("Data/All free paths in plane.csv", self.free_paths_along_y, fmt='%2.4e', header="Ly [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')
         np.savetxt("Data/All travel times.csv", self.travel_times, fmt='%2.4e', header="Travel time [s]", encoding='utf-8')
@@ -93,6 +99,8 @@ class GeneralData(Data):
         return {
             'initial_angles': self.initial_angles,
             'exit_angles': self.exit_angles,
+            'hole_diff_scattering_angles': self.hole_diff_scattering_angles,
+            'hole_spec_scattering_angles': self.hole_spec_scattering_angles,
             'free_paths': self.free_paths,
             'free_paths_along_y': self.free_paths_along_y,
             'frequencies': self.frequencies,
@@ -177,6 +185,53 @@ class ScatteringData(Data):
         }
 
 
+class TriangleScatteringData(Data):
+    """Statistics of phonon scattering events on triangular holes"""
+
+    def __init__(self):
+        """Initialize arrays according to the number of segments"""
+        self.right_wall_diffuse = 0
+        self.right_wall_specular = 0
+        self.left_wall_diffuse = 0
+        self.left_wall_specular = 0
+        self.floor_diffuse = 0
+        self.floor_specular = 0
+
+    def save_scattering_events(self, y, triangle_scattering_places):
+        """Analyze types of scattering at the current timestep and add it to the statistics"""
+
+        try:
+            self.right_wall_diffuse  += 1 if triangle_scattering_places.right_wall == Scattering.DIFFUSE else 0
+            self.right_wall_specular += 1 if triangle_scattering_places.right_wall == Scattering.SPECULAR else 0
+            self.left_wall_diffuse  += 1 if triangle_scattering_places.left_wall == Scattering.DIFFUSE else 0
+            self.left_wall_specular += 1 if triangle_scattering_places.left_wall == Scattering.SPECULAR else 0
+            self.floor_diffuse += 1 if triangle_scattering_places.floor == Scattering.DIFFUSE else 0
+            self.floor_specular += 1 if triangle_scattering_places.floor == Scattering.SPECULAR else 0
+        except:
+            pass
+
+    def write_into_files(self):
+        """Write data into a file"""
+        filename = "Data/Triangle scattering statistics.csv"
+        data = np.vstack(np.array([self.right_wall_diffuse, self.right_wall_specular,
+                self.left_wall_diffuse, self.left_wall_specular,
+                self.floor_diffuse, self.floor_specular])).T
+        header = "Inclined right diffuse, Inclinded right specular, Inclined left diffuse, Inclinded left specular, Floor diffuse, Floor specular"
+        np.savetxt(filename, data, fmt='%1.3e', delimiter=",", header=header, 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 {
+            'right_wall_diffuse': self.right_wall_diffuse,
+            'right_wall_specular': self.right_wall_specular,
+            'left_wall_diffuse': self.left_wall_diffuse,
+            'left_wall_specular': self.left_wall_specular,
+            'floor_diffuse': self.floor_diffuse,
+            'floor_specular': self.floor_specular,
+        }
+
+
+
 class SegmentData(Data):
     """Statistics of events happening in different segments"""
 

{freepaths-1.9.2 → freepaths-2.0}/freepaths/flight.py

@@ -40,6 +40,8 @@ class Flight:
         self.travel_time = 0.0
         self.time_since_previous_scattering = 0.0
         self.free_paths = []
+        self.hole_diff_scattering_angles = []
+        self.hole_spec_scattering_angles = []
         self.free_paths_along_y = []
         self.thermal_conductivity = 0.0
 
@@ -61,6 +63,14 @@ class Flight:
         self.free_paths.append(self.free_path)
         self.free_paths_along_y.append(self.free_path_along_y)
 
+    def save_hole_diff_scattering_angle(self, angle):
+        """Save angle of diffuse scattering from the hole"""
+        self.hole_diff_scattering_angles.append(angle)
+
+    def save_hole_spec_scattering_angle(self, angle):
+        """Save angle of specular scattering from the hole"""
+        self.hole_spec_scattering_angles.append(angle)
+
     def restart(self):
         """Restart the flight after a scattering event"""
         self.time_since_previous_scattering = 0.0

{freepaths-1.9.2 → freepaths-2.0}/freepaths/holes.py

@@ -103,11 +103,11 @@ class RectangularHole(Hole):
 
         # Scattering on the top wall:
         elif y > self.y0:
-            scattering_types.holes = horizontal_surface_up_scattering(ph, cf.side_wall_roughness)
+            scattering_types.holes = horizontal_surface_up_scattering(ph, cf.hole_roughness)
 
         # Scattering on the bottom wall:
         else:
-            scattering_types.holes = horizontal_surface_down_scattering(ph, cf.side_wall_roughness)
+            scattering_types.holes = horizontal_surface_down_scattering(ph, cf.hole_roughness)
 
     def get_patch(self, color_holes, cf):
         """Create a patch in the shape of the hole to use in the plots"""
@@ -140,11 +140,16 @@ class TriangularUpHole(Hole):
         # Scattering on the bottom wall of the triangle:
         if (ph.y < self.y0 - self.size_y / 2) and (abs(ph.theta) < pi / 2):
             scattering_types.holes = horizontal_surface_down_scattering(ph, cf.hole_roughness)
+            # triangle_scattering_places.floor = scattering_types.holes
 
         # Scattering on the sidewalls of the triangle:
         else:
             beta = atan(0.5 * self.size_x / self.size_y)
             scattering_types.holes = inclined_surfaces_up_scattering(ph, beta, x, self.x0, cf.hole_roughness)
+            # if x > self.x0:
+                # triangle_scattering_places.right_wall = scattering_types.holes
+            # else:
+                # triangle_scattering_places.left_wall = scattering_types.holes
 
     def get_patch(self, color_holes, cf):
         """Create a patch in the shape of the hole to use in the plots"""

{freepaths-1.9.2 → freepaths-2.0}/freepaths/main_tracing.py

@@ -14,7 +14,7 @@ from freepaths.config import cf
 from freepaths.run_phonon import run_phonon
 from freepaths.phonon import Phonon
 from freepaths.flight import Flight
-from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData
+from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
 from freepaths.progress import Progress
 from freepaths.materials import Si, SiC, Graphite
 from freepaths.maps import ScatteringMap, ThermalMaps
@@ -54,6 +54,7 @@ class PhononSimulator:
         self.general_stats = GeneralData()
         self.segment_stats = SegmentData()
         self.path_stats = PathData()
+        self.places_stats = TriangleScatteringData()
         self.scatter_maps = ScatteringMap()
         self.thermal_maps = ThermalMaps()
 
@@ -65,7 +66,7 @@ class PhononSimulator:
         flight = Flight(phonon)
 
         # Run this phonon through the structure:
-        run_phonon(phonon, flight, self.scatter_stats, self.segment_stats, self.thermal_maps, self.scatter_maps, self.material)
+        run_phonon(phonon, flight, self.scatter_stats, self.places_stats, self.segment_stats, self.thermal_maps, self.scatter_maps, self.material)
 
         # Record the properties returned for this phonon:
         self.general_stats.save_phonon_data(phonon)
@@ -97,6 +98,7 @@ class PhononSimulator:
         collected_data = {
             'scatter_stats': self.scatter_stats.dump_data(),
             'general_stats': self.general_stats.dump_data(),
+            'places_stats': self.places_stats.dump_data(),
             'segment_stats': self.segment_stats.dump_data(),
             'path_stats': self.path_stats.dump_data(),
             'scatter_maps': self.scatter_maps.dump_data(),
@@ -180,6 +182,7 @@ def main(input_file):
     # Initiate data structures to collect the data from the workers:
     # material = Material(cf.media, num_points=cf.number_of_phonons+1)
     scatter_stats = ScatteringData()
+    places_stats = TriangleScatteringData()
     general_stats = GeneralData()
     segment_stats = SegmentData()
     path_stats = PathData()
@@ -200,6 +203,7 @@ def main(input_file):
     execution_time_list = []
     for collected_data in result_list:
         scatter_stats.read_data(collected_data['scatter_stats'])
+        places_stats.read_data(collected_data['places_stats'])
         general_stats.read_data(collected_data['general_stats'])
         segment_stats.read_data(collected_data['segment_stats'])
         path_stats.read_data(collected_data['path_stats'])
@@ -235,6 +239,7 @@ def main(input_file):
     sys.stdout.write("\rSaving raw data...")
     general_stats.write_into_files()
     scatter_stats.write_into_files()
+    places_stats.write_into_files()
     segment_stats.write_into_files()
     thermal_maps.write_into_files()
     scatter_maps.write_into_files()

{freepaths-1.9.2 → freepaths-2.0}/freepaths/maps.py

@@ -67,7 +67,7 @@ class ScatteringMap(Maps):
 
         # Save into file:
         header = "Specular X, Specular Y, Diffuse X, Diffuse Y, Internal X, Internal Y"
-        np.savetxt("Data/Scattering map.csv", data, fmt='%1.2e', delimiter=",", header=header, encoding='utf-8')
+        np.savetxt("Data/Scattering map.csv", data, fmt='%1.3e', delimiter=",", header=header, 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"""

{freepaths-1.9.2 → freepaths-2.0}/freepaths/materials.py

@@ -40,7 +40,7 @@ class Si:
 
     def assign_heat_capacity(self):
         """Calculate heat capacity [J/kg/K] in 3 - 300K range using the polynomial fits"""
-        below_20K_coeffs = np.array([0.00055196, -0.0052611, 0.03086194, -0.05493787])
+        below_20K_coeffs = np.array([0.00044801, -0.00239681,  0.00756769])
         between_20_and_50K_coeffs = np.array([-9.26222400e-04, 1.49879304e-01, -4.37458293e+00, 3.84245589e+01])
         above_50K_coeffs = np.array([-2.75839317e-06, -5.16662077e-03, 4.66701391e+00, -1.49876958e+02])
         if self.temp < 20:

{freepaths-1.9.2 → freepaths-2.0}/freepaths/output_info.py

@@ -46,55 +46,55 @@ def output_scattering_information(scatter_stats):
     total_hole = np.sum(scatter_stats.hole_diffuse) + np.sum(scatter_stats.hole_specular)
     total_pill = np.sum(scatter_stats.pillar_diffuse) + np.sum(scatter_stats.pillar_specular)
 
-    scat_on_walls = 100*(np.sum(scatter_stats.wall_diffuse) +
+    sc_on_walls = 100*(np.sum(scatter_stats.wall_diffuse) +
                          np.sum(scatter_stats.wall_specular)) / total
-    scat_on_walls_diff = 100*np.sum(scatter_stats.wall_diffuse) / total_wall
-    scat_on_walls_spec = 100*np.sum(scatter_stats.wall_specular) / total_wall
+    sc_on_walls_diff = 100*np.sum(scatter_stats.wall_diffuse) / total_wall
+    sc_on_walls_spec = 100*np.sum(scatter_stats.wall_specular) / total_wall
 
-    scat_on_topbot = 100*(np.sum(scatter_stats.top_diffuse) +
+    sc_on_topbot = 100*(np.sum(scatter_stats.top_diffuse) +
                           np.sum(scatter_stats.top_specular)) / total
 
     if total_topbot != 0:
-        scat_on_topbot_diff = 100*np.sum(scatter_stats.top_diffuse) / total_topbot
-        scat_on_topbot_spec = 100*np.sum(scatter_stats.top_specular) / total_topbot
+        sc_on_topbot_diff = 100*np.sum(scatter_stats.top_diffuse) / total_topbot
+        sc_on_topbot_spec = 100*np.sum(scatter_stats.top_specular) / total_topbot
     else:
-        scat_on_topbot_diff = 0
-        scat_on_topbot_spec = 0
+        sc_on_topbot_diff = 0
+        sc_on_topbot_spec = 0
 
     retherm = 100*np.sum(scatter_stats.hot_side) / total
     internal = 100*np.sum(scatter_stats.internal) / total
 
     info1 = (
-            f'\n{scat_on_walls:.2f}% - scattering on side walls ',
-            f'({scat_on_walls_diff:.2f}% - diffuse, ',
-            f'{scat_on_walls_spec:.2f}% - specular)',
-            f'\n{scat_on_topbot:.2f}% - scattering on top and bottom walls ',
-            f'({scat_on_topbot_diff:.2f}% - diffuse, ',
-            f'{scat_on_topbot_spec:.2f}% - specular)',
+            f'\n{sc_on_walls:.2f}% - scattering on side walls ',
+            f'({sc_on_walls_diff:.2f}% - diffuse, ',
+            f'{sc_on_walls_spec:.2f}% - specular)',
+            f'\n{sc_on_topbot:.2f}% - scattering on top and bottom walls ',
+            f'({sc_on_topbot_diff:.2f}% - diffuse, ',
+            f'{sc_on_topbot_spec:.2f}% - specular)',
             f'\n{retherm:.2f}% - rethermalization at the hot side',
             f'\n{internal:.2f}% - internal scattering processes',
     )
 
     if cf.holes:
-        scat_on_holes = 100*(np.sum(scatter_stats.hole_diffuse) +
+        sc_on_holes = 100*(np.sum(scatter_stats.hole_diffuse) +
                              np.sum(scatter_stats.hole_specular)) / total
-        scat_on_holes_diff = 100*np.sum(scatter_stats.hole_diffuse) / total_hole
-        scat_on_holes_spec = 100*np.sum(scatter_stats.hole_specular) / total_hole
+        sc_on_holes_diff = 100*np.sum(scatter_stats.hole_diffuse) / total_hole
+        sc_on_holes_spec = 100*np.sum(scatter_stats.hole_specular) / total_hole
         info2 = (
-                f'\n{scat_on_holes:.2f}% - scattering on hole walls ',
-                f'({scat_on_holes_diff:.2f}% - diffuse, ',
-                f'{scat_on_holes_spec:.2f}% - specular)',
+                f'\n{sc_on_holes:.2f}% - scattering on hole walls ',
+                f'({sc_on_holes_diff:.2f}% - diffuse, ',
+                f'{sc_on_holes_spec:.2f}% - specular)',
         )
 
     if cf.pillars:
-        scat_on_pill = 100*(np.sum(scatter_stats.pillar_diffuse) +
+        sc_on_pill = 100*(np.sum(scatter_stats.pillar_diffuse) +
                             np.sum(scatter_stats.pillar_specular)) / total
-        scat_on_pill_diff = 100*np.sum(scatter_stats.pillar_diffuse) / total_pill
-        scat_on_pill_spec = 100*np.sum(scatter_stats.pillar_specular) / total_pill
+        sc_on_pill_diff = 100*np.sum(scatter_stats.pillar_diffuse) / total_pill
+        sc_on_pill_spec = 100*np.sum(scatter_stats.pillar_specular) / total_pill
         info3 = (
-                f'\n{scat_on_pill:.2f}% - scattering on pillar walls ',
-                f'({scat_on_pill_diff:.2f}% - diffuse, ',
-                f'{scat_on_pill_spec:.2f}% - specular)'
+                f'\n{sc_on_pill:.2f}% - scattering on pillar walls ',
+                f'({sc_on_pill_diff:.2f}% - diffuse, ',
+                f'{sc_on_pill_spec:.2f}% - specular)'
         )
 
     # Write info into a text file:
@@ -116,7 +116,7 @@ def output_parameter_warnings():
     long_travel_times = travel_times[travel_times > time_of_stabilization]
     percentage = (len(long_travel_times) / len(travel_times)) * 100
     if percentage > 10:
-        logging.warning("Travel time of {percentage}% of phonons was longer than the stabilization period.\n" +
+        logging.warning(f"Travel time of {percentage}% of phonons was longer than the stabilization period.\n" +
                           "Increase stabilization period as the thermal conductivity might be incorrect.")
 
     # Check if pixel size is too small:
@@ -129,4 +129,4 @@ def output_parameter_warnings():
     # Check how many phonons reached the cold side during simulation:
     percentage = int(100 * np.count_nonzero(travel_times) / cf.number_of_phonons)
     if percentage < 95:
-        logging.warning("Only {percentage}% of phonons reached the cold side. Increase number of timesteps.")
+        logging.warning(f"Only {percentage}% of phonons reached the cold side. Increase number of timesteps.")

{freepaths-1.9.2 → freepaths-2.0}/freepaths/output_plots.py

@@ -1,5 +1,7 @@
 """Module that calculates and outputs vaious plots and distributions from the saved files"""
 
+import logging
+import sys
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.patches as patches
@@ -17,7 +19,7 @@ if 'Arial' in all_fonts:
     plt.rcParams['font.family'] = 'Arial'
 else:
     # Use a generic font or specify multiple options
-    print('Warning: Arial font not available. Falling back on other sans-serif font')
+    logging.warning("Arial font not available. Falling back on default sans-serif font")
     plt.rcParams['font.family'] = ['sans-serif']
 plt.rcParams['axes.titlesize'] = 10
 plt.rcParams['axes.labelsize'] = 10
@@ -35,6 +37,7 @@ plt.rcParams['figure.figsize'] = [5, 3.5]
 plt.rcParams['figure.dpi'] = 300
 plt.rcParams['savefig.dpi'] = 300
 plt.rcParams['legend.fontsize'] = 8
+plt.rcParams['grid.linewidth'] = 0.5
 
 
 def distribution_calculation(filename, data_range, number_of_nodes):
@@ -52,6 +55,8 @@ def angle_distribution_calculation():
     """Analyse measured phonon angles and create their distribution"""
     all_exit_angles = np.loadtxt("Data/All exit angles.csv", dtype='float', encoding='utf-8')
     initial_angles = np.loadtxt("Data/All initial angles.csv", dtype='float', encoding='utf-8')
+    hole_diff_angles = np.loadtxt("Data/All hole diffuse scattering angles.csv", dtype='float', encoding='utf-8')
+    hole_spec_angles = np.loadtxt("Data/All hole specular scattering angles.csv", dtype='float', encoding='utf-8')
     distribution = np.zeros((360, 3))
     distribution[:, 0] = range(-180, 180)
     exit_angles = all_exit_angles[all_exit_angles != 0]
@@ -60,6 +65,17 @@ def angle_distribution_calculation():
     return distribution
 
 
+def scattering_angle_distribution_calculation():
+    """Analyse scattering phonon angles and create their distribution"""
+    hole_diff_angles = np.loadtxt("Data/All hole diffuse scattering angles.csv", dtype='float', encoding='utf-8')
+    hole_spec_angles = np.loadtxt("Data/All hole specular scattering angles.csv", dtype='float', encoding='utf-8')
+    distribution = np.zeros((360, 3))
+    distribution[:, 0] = range(-180, 180)
+    distribution[:, 1], _ = np.histogram(np.degrees(hole_diff_angles), 360, range=(-180, 180))
+    distribution[:, 2], _ = np.histogram(np.degrees(hole_spec_angles), 360, range=(-180, 180))
+    return distribution
+
+
 def wavelength_distribution_calculation(number_of_nodes):
     """Calculate phonon wavelength distribution from their frequencies and velocities"""
     frequencies = np.loadtxt("Data/All initial frequencies.csv", encoding='utf-8')
@@ -100,7 +116,7 @@ def plot_cumulative_thermal_conductivity(mfp_sampling):
 
 
 def plot_angle_distribution():
-    """Plot distribution of angles"""
+    """Plot distribution of initial and exit angles"""
     angle_distributions = angle_distribution_calculation()
     fig, ax = plt.subplots()
     ax.plot(angle_distributions[:, 0], angle_distributions[:, 1], 'royalblue')
@@ -114,6 +130,24 @@ def plot_angle_distribution():
     np.savetxt('Data/Distribution of angles.csv', angle_distributions, fmt='%1.3e', delimiter=",")
 
 
+def plot_scattering_angle_distribution():
+    """Plot distribution of hole scattering angles"""
+    angle_distributions = scattering_angle_distribution_calculation()
+    fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
+    ax.grid(zorder=0)
+    ax.plot(np.deg2rad(angle_distributions[:, 0]), angle_distributions[:, 1], 'royalblue', label="Diffuse", zorder=2)
+    ax.fill_between(np.deg2rad(angle_distributions[:, 0]), angle_distributions[:, 1], 0, alpha=0.2, zorder=2)
+    ax.plot(np.deg2rad(angle_distributions[:, 0]), angle_distributions[:, 2], 'deeppink', label="Specular", zorder=3)
+    ax.fill_between(np.deg2rad(angle_distributions[:, 0]), angle_distributions[:, 2], 0, alpha=0.2, zorder=3)
+    ax.set_theta_zero_location('N')
+    ax.set_theta_direction(-1)
+    ax.legend(facecolor='white', framealpha=1, ncols=2, loc="lower center", bbox_to_anchor=(0.5, -0.17))
+    ax.set_title('Number of scattered phonons per angle')
+    fig.savefig("Distribution of hole scattering angles.pdf", format='pdf', bbox_inches="tight")
+    plt.close(fig)
+    np.savetxt('Data/Distribution of hole scattering angles.csv', angle_distributions, fmt='%1.3e', delimiter=",")
+
+
 def plot_free_path_distribution():
     """Plot distribution of free path"""
     filename = "Data/All free paths.csv"
@@ -227,16 +261,16 @@ def plot_thermal_conductivity():
     ax.add_patch(rectangle_mat)
 
     # Plot the averaged values in the averaging range:
-    ax.plot([av_start, av_end], [av_mat_tc, av_mat_tc], '-', markersize=2, linewidth=2, color='deeppink', label='$\overline{\kappa}_{mat}$')
-    ax.plot([av_start, av_end], [av_eff_tc, av_eff_tc], '-', markersize=2, linewidth=2, color='royalblue', label='$\overline{\kappa}_{eff}$')
+    ax.plot([av_start, av_end], [av_mat_tc, av_mat_tc], '-', markersize=2, linewidth=2, color='deeppink', label=r'$\overline{\kappa}_{mat}$')
+    ax.plot([av_start, av_end], [av_eff_tc, av_eff_tc], '-', markersize=2, linewidth=2, color='royalblue', label=r'$\overline{\kappa}_{eff}$')
 
     ax.set_ylabel('Thermal conductivity (W/m·K)')
     ax.set_xlabel('Time (ns)')
 
     ax.set_xlim(left=0.0)
     ax.legend()
-    kappa_mat_str = "$\overline{\kappa}_{mat}$"
-    kappa_eff_str = "$\overline{\kappa}_{eff}$"
+    kappa_mat_str = r"$\overline{\kappa}_{mat}$"
+    kappa_eff_str = r"$\overline{\kappa}_{eff}$"
     ax.set_title(f'{kappa_mat_str} = {av_mat_tc} ± {std_mat_tc} W/m·K, {kappa_eff_str} = {av_eff_tc} ± {std_eff_tc} W/m·K', color='grey')
     fig.savefig("Thermal conductivity.pdf", format='pdf', bbox_inches="tight")
     plt.close(fig)
@@ -312,7 +346,7 @@ def plot_heat_flux_map(file, label, units="a.u."):
     fig = plt.figure()
     heat_flux_map = np.genfromtxt(file, unpack=False, delimiter=',', skip_header=0, encoding='utf-8')
     heat_flux_map = np.flipud(heat_flux_map)
-    minimum_of_colorbar = 1e6
+    minimum_of_colorbar = 1e5
     boundaries = [(-cf.width / 2) * 1e6, (cf.width / 2) * 1e6, 0, cf.length * 1e6]
     plt.imshow(heat_flux_map, cmap='jet', interpolation='none', extent=boundaries,
                norm=LogNorm(vmin=minimum_of_colorbar, vmax=np.amax(heat_flux_map)))
@@ -456,7 +490,7 @@ def plot_material_properties():
     elif cf.media == "Graphite":
         material = Graphite(cf.temp)
     else:
-        print(f"Material {cf.media} is not supported")
+        logging.error(f"Material {cf.media} is not supported")
         sys.exit()
 
     # Plot phonon dispersion:
@@ -469,35 +503,45 @@ def plot_material_properties():
     ax.set_xlim(left=0)
 
     # Add material properties:
-    ax.set_title(f'{material.name},  T = {cf.temp} K,  C$_p$ = {material.heat_capacity:.3f} J/kg·K,  ρ = {material.density} kg/m³')
+    ax.set_title(f'{material.name},  T = {cf.temp} K,  C$_p$ = {material.heat_capacity:.3f} J/kg·K,  ρ = {material.density} kg/m³', color="grey")
 
     fig.savefig("Material properties.pdf", format='pdf', bbox_inches="tight")
     plt.close(fig)
 
 
 def plot_data(mfp_sampling=False):
-    """Create plots of various distributions"""
-    plot_structure()
-    plot_trajectories()
-    plot_angle_distribution()
-    plot_free_path_distribution()
-    plot_frequency_distribution()
-    plot_wavelength_distribution()
-    plot_travel_time_distribution()
-    plot_mean_free_path_distribution()
-    plot_velocity_distribution()
-    plot_time_in_segments()
-    plot_thermal_conductivity()
-    plot_temperature_profile()
-    plot_heat_flux_profile()
-    plot_thermal_map()
-    plot_pixel_volumes()
-    plot_scattering_statistics()
+    """Create plots of various distributions, maps, profiles, and other quantities"""
+    function_list = [
+        plot_structure,
+        plot_trajectories,
+        plot_angle_distribution,
+        plot_scattering_angle_distribution,
+        plot_free_path_distribution,
+        plot_frequency_distribution,
+        plot_wavelength_distribution,
+        plot_travel_time_distribution,
+        plot_mean_free_path_distribution,
+        plot_velocity_distribution,
+        plot_time_in_segments,
+        plot_thermal_conductivity,
+        plot_temperature_profile,
+        plot_heat_flux_profile,
+        plot_thermal_map,
+        plot_pixel_volumes,
+        plot_scattering_statistics,
+        plot_scattering_map,
+        plot_material_properties,
+    ]
+
+    # Run main functions and handle exceptions:
+    for func in function_list:
+        try:
+            func()
+        except Exception as e:
+            logging.warning(f"Function {func.__name__} failed: {e}")
+
+    # Run additional functions:
     plot_cumulative_thermal_conductivity(mfp_sampling)
     plot_heat_flux_map(file="Data/Heat flux map xy.csv", label="Heat flux map", units="W/m²")
     plot_heat_flux_map(file="Data/Heat flux map x.csv", label="Heat flux map x", units="W/m²")
     plot_heat_flux_map(file="Data/Heat flux map y.csv", label="Heat flux map y", units="W/m²")
-    # plot_heat_flux_map(file="Data/Heat flux map x weighted.csv", label="Heat flux map x weighted", units="W/m²")
-    # plot_heat_flux_map(file="Data/Heat flux map y weighted.csv", label="Heat flux map y weighted", units="W/m²")
-    plot_scattering_map()
-    plot_material_properties()

{freepaths-1.9.2 → freepaths-2.0}/freepaths/run_phonon.py

@@ -5,14 +5,15 @@ After the run, we record various parameters of this run into flight object.
 
 from freepaths.config import cf
 from freepaths.scattering import internal_scattering, surface_scattering, reinitialization
-from freepaths.scattering_types import ScatteringTypes
+from freepaths.scattering_types import ScatteringTypes, ScatteringPlaces
 
 
-def run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatter_maps, material):
+def run_phonon(phonon, flight, scatter_stats, places_stats, segment_stats, thermal_maps, scatter_maps, material):
     """Run one phonon through the system and record parameters of this run"""
 
     # Initialize object that will store scattering types:
     scattering_types = ScatteringTypes()
+    triangle_scattering_places = ScatteringPlaces()
 
     # Run the phonon step-by-step:
     for step_number in range(cf.number_of_timesteps):
@@ -21,7 +22,7 @@ def run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatt
             # Check if different scattering events happened during current time step:
             if cf.include_internal_scattering:
                 internal_scattering(phonon, flight, scattering_types)
-            surface_scattering(phonon, scattering_types)
+            surface_scattering(phonon, scattering_types, triangle_scattering_places)
             reinitialization(phonon, scattering_types)
 
             # If any scattering has occurred, record it:
@@ -43,6 +44,15 @@ def run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatt
                 phonon.assign_internal_scattering_time(material)
                 if cf.is_two_dimensional_material:
                     phonon.phi = 0.0
+
+            # If hole scattering has occured, record it:
+            if triangle_scattering_places.is_scattered:
+                places_stats.save_scattering_events(phonon.y, triangle_scattering_places)
+            if scattering_types.is_diffuse_on_hole:
+                flight.save_hole_diff_scattering_angle(phonon.theta)
+            if scattering_types.is_specular_on_hole:
+                flight.save_hole_spec_scattering_angle(phonon.theta)
+
             else:
                 flight.add_step(cf.timestep)
 
@@ -50,6 +60,7 @@ def run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatt
             thermal_maps.add_energy_to_maps(phonon, step_number, material)
             segment_stats.record_time_in_segment(phonon.y)
             scattering_types.reset()
+            triangle_scattering_places.reset()
             phonon.move()
 
         # If the phonon reached cold side, record it and break the loop:

{freepaths-1.9.2 → freepaths-2.0}/freepaths/scattering.py

@@ -107,7 +107,7 @@ def ceiling_scattering(ph, scattering_types, x, y, z):
         scattering_types.top_bottom = in_plane_surface_scattering(ph, cf.top_roughness)
 
 
-def surface_scattering(ph, scattering_types):
+def surface_scattering(ph, scattering_types, triangle_scattering_places):
     """Check for a surface scattering on this step"""
 
     # Preliminary move to see if phonon would cross something:

{freepaths-1.9.2 → freepaths-2.0}/freepaths/scattering_primitives.py

@@ -38,21 +38,20 @@ def vertical_surface_left_scattering(ph, roughness, cf, is_diffuse=False):
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
-    if random() < p and not is_diffuse:
+    if random() < p and (not is_diffuse):
         ph.theta = - ph.theta
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        for attempt in range(10):
+    for attempt in range(10):
 
-            # Lambert cosine distribution:
-            ph.theta = -pi/2 + asin(2*random() - 1)
-            ph.phi = asin((asin(2*random() - 1))/(pi/2))
+        # Lambert cosine distribution:
+        ph.theta = -pi/2 + asin(2*random() - 1)
+        ph.phi = asin((asin(2*random() - 1))/(pi/2))
 
-            # Accept the angles if they do not cause new scattering:
-            if no_new_scattering(ph, cf):
-                return Scattering.DIFFUSE
+        # Accept the angles if they do not cause new scattering:
+        if no_new_scattering(ph, cf):
+            return Scattering.DIFFUSE
 
 
 def vertical_surface_right_scattering(ph, roughness, cf, is_diffuse=False):
@@ -63,21 +62,20 @@ def vertical_surface_right_scattering(ph, roughness, cf, is_diffuse=False):
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
-    if random() < p and not is_diffuse:
+    if random() < p and (not is_diffuse):
         ph.theta = - ph.theta
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        for attempt in range(10):
+    for attempt in range(10):
 
-            # Lambert cosine distribution:
-            ph.theta = +pi/2 + asin(2*random() - 1)
-            ph.phi = asin((asin(2*random() - 1))/(pi/2))
+        # Lambert cosine distribution:
+        ph.theta = +pi/2 + asin(2*random() - 1)
+        ph.phi = asin((asin(2*random() - 1))/(pi/2))
 
-            # Accept the angles if they do not cause new scattering:
-            if no_new_scattering(ph, cf):
-                return Scattering.DIFFUSE
+        # Accept the angles if they do not cause new scattering:
+        if no_new_scattering(ph, cf):
+            return Scattering.DIFFUSE
 
 
 def horizontal_surface_down_scattering(ph, roughness, is_diffuse=False):
@@ -88,17 +86,16 @@ def horizontal_surface_down_scattering(ph, roughness, is_diffuse=False):
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
-    if random() < p and not is_diffuse:
+    if random() < p and (not is_diffuse):
         ph.theta = sign(ph.theta)*pi - ph.theta
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        # Lambert cosine distribution:
-        rand_sign = sign((2*random() - 1))
-        ph.theta = rand_sign*pi/2 + rand_sign*acos(random())
-        ph.phi = asin((asin(2*random() - 1))/(pi/2))
-        return Scattering.DIFFUSE
+    # Lambert cosine distribution:
+    rand_sign = sign((2*random() - 1))
+    ph.theta = rand_sign*pi/2 + rand_sign*acos(random())
+    ph.phi = asin((asin(2*random() - 1))/(pi/2))
+    return Scattering.DIFFUSE
 
 
 def horizontal_surface_up_scattering(ph, roughness, is_diffuse=False):
@@ -114,18 +111,17 @@ def horizontal_surface_up_scattering(ph, roughness, is_diffuse=False):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        # Lambert cosine distribution:
-        ph.theta = asin(2*random() - 1)
-        ph.phi = asin((asin(2*random() - 1))/(pi/2))
-        return Scattering.DIFFUSE
+    # Lambert cosine distribution:
+    ph.theta = asin(2*random() - 1)
+    ph.phi = asin((asin(2*random() - 1))/(pi/2))
+    return Scattering.DIFFUSE
 
 
 def inclined_surfaces_down_scattering(ph, beta, x, x0, roughness):
     """Scattering from a inclined surfaces pointing down like V"""
 
     # Calculate angle to the surface and specular scattering probability:
-    a = acos(cos(ph.phi)*cos(ph.theta - sign(x - x0)*(pi/2 - beta)))
+    a = acos(cos(ph.phi)*cos(pi/2 - abs(ph.theta) - beta))
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
@@ -134,18 +130,18 @@ def inclined_surfaces_down_scattering(ph, beta, x, x0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        rand_sign = sign((2*random() - 1))
-        ph.theta = rand_sign*pi - rand_sign*asin(random()) - sign(x - x0)*(pi/2 - beta)
-        ph.phi = asin((asin(2*random() - 1))/(pi/2))
-        return Scattering.DIFFUSE
+    rand_sign = sign((2*random() - 1))
+    ph.theta = rand_sign*pi - rand_sign*asin(random()) - sign(x - x0)*(pi/2 - beta)
+    ph.phi = asin((asin(2*random() - 1))/(pi/2))
+    return Scattering.DIFFUSE
 
 
 def inclined_surfaces_up_scattering(ph, beta, x, x0, roughness):
     """Scattering from a inclined surfaces pointing up like ^"""
 
     # Calculate angle to the surface and specular scattering probability:
-    a = acos(cos(ph.phi)*cos(ph.theta + sign(x - x0)*(pi/2 - beta)))
+    a = acos(cos(ph.phi)*cos(pi/2 - abs(ph.theta) + beta))
+    # a = acos(cos(ph.phi)*cos(abs(ph.theta) - pi/2 + beta))
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
@@ -154,11 +150,9 @@ def inclined_surfaces_up_scattering(ph, beta, x, x0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        # Lambert cosine distribution:
-        ph.theta = asin(2*random() - 1) + sign(x - x0)*(pi/2 - beta)
-        ph.phi = asin((asin(2*random() - 1))/(pi/2))
-        return Scattering.DIFFUSE
+    ph.theta = asin(2*random() - 1) + sign(x - x0)*(pi/2 - beta)
+    ph.phi = asin((asin(2*random() - 1))/(pi/2))
+    return Scattering.DIFFUSE
 
 
 def in_plane_surface_scattering(ph, roughness):
@@ -174,22 +168,21 @@ def in_plane_surface_scattering(ph, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        # Random distribution:
-        # theta = -pi + random()*2*pi
-        # phi = -asin(random())
+    # Random distribution:
+    # theta = -pi + random()*2*pi
+    # phi = -asin(random())
 
-        # Lambert cosine distribution:
-        ph.theta = - pi + random()*2*pi
-        ph.phi = - sign(ph.phi) *  random()*pi/2
-        return Scattering.DIFFUSE
+    # Lambert cosine distribution:
+    ph.theta = - pi + random()*2*pi
+    ph.phi = - sign(ph.phi) *  random()*pi/2
+    return Scattering.DIFFUSE
 
 
 def circle_outer_scattering(ph, tangent_theta, y, y0, roughness, cf):
     """Scattering from the outer surface of the circle"""
 
     # Calculate angle to the surface and specular scattering probability:
-    a = acos(cos(ph.phi)*cos(ph.theta + sign(y - y0)*tangent_theta))
+    a = acos(cos(ph.phi)*cos(ph.theta - tangent_theta))
     p = specularity(a, roughness, ph.wavelength)
 
     # Specular scattering:
@@ -198,20 +191,19 @@ def circle_outer_scattering(ph, tangent_theta, y, y0, roughness, cf):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        for attempt in range(10):
+    for attempt in range(10):
 
-            # Random distribution:
-            # theta = tangent_theta - (-pi/2 + pi*random()) - pi*(y < y0)
-            # phi = asin(2*random() - 1)
+        # Random distribution:
+        # theta = tangent_theta - (-pi/2 + pi*random()) - pi*(y < y0)
+        # phi = asin(2*random() - 1)
 
-            # Lambert cosine distribution:
-            ph.theta = tangent_theta - (asin(2*random() - 1)) - pi*(y < y0)
-            ph.phi = asin((asin(2*random() - 1))/(pi/2))
+        # Lambert cosine distribution:
+        ph.theta = tangent_theta - (asin(2*random() - 1)) - pi*(y < y0)
+        ph.phi = asin((asin(2*random() - 1))/(pi/2))
 
-            # Accept the angles only if they do not immediately cause new scattering:
-            if no_new_scattering(ph, cf):
-                return Scattering.DIFFUSE
+        # Accept the angles only if they do not immediately cause new scattering:
+        if no_new_scattering(ph, cf):
+            return Scattering.DIFFUSE
 
 
 def circle_inner_scattering(ph, tangent_theta, y, y0, roughness):
@@ -226,10 +218,9 @@ def circle_inner_scattering(ph, tangent_theta, y, y0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        ph.theta = tangent_theta - asin(2*random()-1) + pi*(y >= y0)
-        ph.phi = asin((asin(2*random() - 1))/(pi/2))
-        return Scattering.DIFFUSE
+    ph.theta = tangent_theta - asin(2*random()-1) + pi*(y >= y0)
+    ph.phi = asin((asin(2*random() - 1))/(pi/2))
+    return Scattering.DIFFUSE
 
 
 def circle_inclined_inner_scattering(ph, tangent_theta, y, y0, roughness):
@@ -263,7 +254,6 @@ def circle_inclined_inner_scattering(ph, tangent_theta, y, y0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    else:
-        ph.theta = tangent_theta - asin(2*random()-1) + pi*(y >= y0)
-        ph.phi = asin((asin(2*random() - 1))/(pi/2)) # - (pi / 2 - pillar.wall_angle)
-        return Scattering.DIFFUSE
+    ph.theta = tangent_theta - asin(2*random()-1) + pi*(y >= y0)
+    ph.phi = asin((asin(2*random() - 1))/(pi/2)) # - (pi / 2 - pillar.wall_angle)
+    return Scattering.DIFFUSE

{freepaths-1.9.2 → freepaths-2.0}/freepaths/scattering_types.py

@@ -36,9 +36,19 @@ class ScatteringTypes:
 
     @property
     def is_internal(self):
-        """Is any of the scattering types diffuse?"""
+        """Is the scattering type internal?"""
         return self.internal is not None
 
+    @property
+    def is_diffuse_on_hole(self):
+        """Was there a diffuse scattering on holes?"""
+        return self.holes == Scattering.DIFFUSE
+
+    @property
+    def is_specular_on_hole(self):
+        """Was there a specular scattering on holes?"""
+        return self.holes == Scattering.SPECULAR
+
     @property
     def is_scattered(self):
         """Has any of the scattering events occurred?"""
@@ -57,3 +67,26 @@ class ScatteringTypes:
         self.walls = None
         self.internal = None
         self.hot_side = None
+
+
+class ScatteringPlaces:
+    """Phonon scattering places on a triangle"""
+
+    def __init__(self):
+        """Initialize possible scattering places"""
+        self.right_wall = None
+        self.left_wall = None
+        self.floor = None
+
+    @property
+    def is_scattered(self):
+        """Has any of the scattering events occurred?"""
+        return any([self.right_wall,
+                    self.left_wall,
+                    self.floor])
+
+    def reset(self):
+        """Reset all scattering places to None"""
+        self.right_wall = None
+        self.left_wall = None
+        self.floor = None

{freepaths-1.9.2 → freepaths-2.0}/freepaths.egg-info/PKG-INFO

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