freepaths 2.0__tar.gz → 2.1__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: freepaths
-Version: 2.0
+Version: 2.1
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -11,18 +11,28 @@ Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Environment :: Console
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
-Requires-Python: ~=3.8
+Requires-Python: ~=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: imageio
 Requires-Dist: colorama
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # FreePATHS - Free Phonon And Thermal Simulator
 

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

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

{freepaths-2.0 → freepaths-2.1}/freepaths/animation.py

@@ -8,7 +8,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 
 from freepaths.config import cf
-from freepaths.output_structure import draw_structure
+from freepaths.output_structure import draw_structure_top_view
 
 
 def generate_frames_xy():
@@ -28,7 +28,7 @@ def generate_frames_xy():
         fig, ax = plt.subplots()
 
         # Draw the structure:
-        patches = draw_structure(cf, color_back=cf.output_structure_color)
+        patches = draw_structure_top_view(cf, color_back=cf.output_structure_color)
 
         for patch in patches:
             ax.add_patch(patch)

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

@@ -9,7 +9,7 @@ import logging
 from colorama import Fore, Style
 
 from freepaths.sources import Distributions
-from freepaths.holes import *
+from freepaths.scatterers import *
 
 # Import a default input file:
 from freepaths.default_config import *
@@ -110,10 +110,12 @@ class Config:
         self.top_roughness = TOP_ROUGHNESS
         self.bottom_roughness = BOTTOM_ROUGHNESS
         self.pillar_top_roughness = PILLAR_TOP_ROUGHNESS
+        self.interface_roughness = INTERFACE_ROUGHNESS
 
         # Hole array parameters:
         self.holes = HOLES
         self.pillars = PILLARS
+        self.interfaces = INTERFACES
 
         # Multiprocessing:
         self.num_workers = NUMBER_OF_PROCESSES

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

@@ -126,6 +126,8 @@ class ScatteringData(Data):
         self.pillar_specular = np.zeros(cf.number_of_length_segments+1)
         self.hot_side = np.zeros(cf.number_of_length_segments+1)
         self.internal = np.zeros(cf.number_of_length_segments+1)
+        self.interfaces_diffuse = np.zeros(cf.number_of_length_segments+1)
+        self.interfaces_specular = np.zeros(cf.number_of_length_segments+1)
         self.total = np.zeros(cf.number_of_length_segments+1)
 
     def save_scattering_events(self, y, scattering_types):
@@ -152,6 +154,10 @@ class ScatteringData(Data):
             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
 
+            # Scattering on pillars:
+            self.interfaces_diffuse[segment]  += 1 if scattering_types.interfaces == Scattering.DIFFUSE else 0
+            self.interfaces_specular[segment] += 1 if scattering_types.interfaces == 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
@@ -181,6 +187,8 @@ class ScatteringData(Data):
             'pillar_specular': self.pillar_specular,
             'hot_side': self.hot_side,
             'internal': self.internal,
+            'interfaces_diffuse': self.interfaces_diffuse,
+            'interfaces_specular': self.interfaces_specular,
             'total': self.total
         }
 

{freepaths-2.0 → freepaths-2.1}/freepaths/default_config.py

@@ -69,10 +69,12 @@ PILLAR_ROUGHNESS                 = 2e-9
 TOP_ROUGHNESS                    = 0.2e-9
 BOTTOM_ROUGHNESS                 = 0.2e-9
 PILLAR_TOP_ROUGHNESS             = 0.2e-9
+INTERFACE_ROUGHNESS              = 0.2e-9
 
 # Holes and pillars:
 HOLES                            = []
 PILLARS                          = []
+INTERFACES                       = []
 
 # Multiprocessing:
 NUMBER_OF_PROCESSES              = 10

{freepaths-2.0 → freepaths-2.1}/freepaths/main_mfp_sampling.py

@@ -15,7 +15,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
@@ -45,6 +45,7 @@ def main(input_file):
     scatter_stats = ScatteringData()
     general_stats = GeneralData()
     segment_stats = SegmentData()
+    places_stats = TriangleScatteringData()
     path_stats = PathData()
     scatter_maps = ScatteringMap()
     thermal_maps = ThermalMaps()
@@ -67,7 +68,7 @@ def main(input_file):
             flight = Flight(phonon)
 
             # Run this phonon through the structure:
-            run_phonon(phonon, flight, scatter_stats, segment_stats, thermal_maps, scatter_maps, material)
+            run_phonon(phonon, flight, scatter_stats, places_stats, segment_stats, thermal_maps, scatter_maps, material)
 
             # Heat capacity, Ref. PRB 88 155318 (2013):
             omega = 2 * math.pi * phonon.f

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

@@ -125,7 +125,7 @@ def worker_process(worker_id, total_phonons, shared_list, output_trajectories_of
 def display_workers_finished(finished_workers):
     """ Print out the number of active workers"""
     while True:
-        text_to_display = f'  Workers finished: {finished_workers.value}/{cf.num_workers}'
+        text_to_display = f'  Processes finished: {finished_workers.value}/{cf.num_workers}'
         sys.stdout.write(text_to_display)
         sys.stdout.write(f'\033[{len(text_to_display)}D') # move cursor back
         sys.stdout.flush()

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

@@ -15,24 +15,25 @@ def output_general_information(start_time):
     travel_times = np.loadtxt("Data/All travel times.csv", encoding='utf-8')
     percentage = int(100 * np.count_nonzero(travel_times) / cf.number_of_phonons)
 
+    info = [
+            f'The simulation finished on {time.strftime("%d %B %Y")}, at {time.strftime("%H:%M")}.',
+            f'\nIt took about {int((time.time()-start_time)//60)} min to run.\n',
+            f'\nNumber of phonons = {cf.number_of_phonons}',
+            f'\nNumber of timesteps = {cf.number_of_timesteps}',
+            f'\nLength of a timestep = {cf.timestep} s',
+            f'\nTemperature = {cf.temp} K\n',
+            f'\nMaterial: {cf.media}\n',
+            f'\nLength = {cf.length * 1e9:.1f} nm',
+            f'\nWidth = {cf.width * 1e9:.1f} nm',
+            f'\nThickness = {cf.thickness * 1e9:.1f} nm\n',
+            f'\nSide wall roughness = {cf.side_wall_roughness * 1e9:.1f} nm',
+            f'\nHole roughness = {cf.hole_roughness * 1e9:.1f} nm',
+            f'\nTop roughness = {cf.top_roughness * 1e9:.1f} nm',
+            f'\nBottom roughness = {cf.bottom_roughness * 1e9:.1f} nm',
+            f'\nInterface roughness = {cf.interface_roughness * 1e9:.1f} nm\n',
+            f'\n{percentage:.0f}% of phonons reached the cold side\n'
+            ]
     with open("Information.txt", "w+", encoding="utf-8") as file:
-        info = (
-                f'The simulation finished on {time.strftime("%d %B %Y")}, at {time.strftime("%H:%M")}.',
-                f'\nIt took about {int((time.time()-start_time)//60)} min to run.\n',
-                f'\nNumber of phonons = {cf.number_of_phonons}',
-                f'\nNumber of timesteps = {cf.number_of_timesteps}',
-                f'\nLength of a timestep = {cf.timestep} s',
-                f'\nTemperature = {cf.temp} K\n',
-                f'\nMaterial: {cf.media}\n',
-                f'\nLength = {cf.length * 1e9:.1f} nm',
-                f'\nWidth = {cf.width * 1e9:.1f} nm',
-                f'\nThickness = {cf.thickness * 1e9:.1f} nm\n',
-                f'\nSide wall roughness = {cf.side_wall_roughness * 1e9:.1f} nm',
-                f'\nHole roughness = {cf.hole_roughness * 1e9:.1f} nm',
-                f'\nTop roughness = {cf.top_roughness * 1e9:.1f} nm',
-                f'\nBottom roughness = {cf.bottom_roughness * 1e9:.1f} nm\n',
-                f'\n{percentage:.0f}% of phonons reached the cold side\n'
-        )
         file.writelines(info)
 
 
@@ -45,6 +46,7 @@ def output_scattering_information(scatter_stats):
     total_topbot = np.sum(scatter_stats.top_diffuse) + np.sum(scatter_stats.top_specular)
     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)
+    total_interf = np.sum(scatter_stats.interfaces_diffuse) + np.sum(scatter_stats.interfaces_specular)
 
     sc_on_walls = 100*(np.sum(scatter_stats.wall_diffuse) +
                          np.sum(scatter_stats.wall_specular)) / total
@@ -64,7 +66,7 @@ def output_scattering_information(scatter_stats):
     retherm = 100*np.sum(scatter_stats.hot_side) / total
     internal = 100*np.sum(scatter_stats.internal) / total
 
-    info1 = (
+    info = [
             f'\n{sc_on_walls:.2f}% - scattering on side walls ',
             f'({sc_on_walls_diff:.2f}% - diffuse, ',
             f'{sc_on_walls_spec:.2f}% - specular)',
@@ -73,37 +75,45 @@ def output_scattering_information(scatter_stats):
             f'{sc_on_topbot_spec:.2f}% - specular)',
             f'\n{retherm:.2f}% - rethermalization at the hot side',
             f'\n{internal:.2f}% - internal scattering processes',
-    )
+            ]
 
+    # If scatterers are present, add their information:
     if cf.holes:
         sc_on_holes = 100*(np.sum(scatter_stats.hole_diffuse) +
                              np.sum(scatter_stats.hole_specular)) / total
         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{sc_on_holes:.2f}% - scattering on hole walls ',
-                f'({sc_on_holes_diff:.2f}% - diffuse, ',
-                f'{sc_on_holes_spec:.2f}% - specular)',
-        )
+        info1.extend([
+                    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:
         sc_on_pill = 100*(np.sum(scatter_stats.pillar_diffuse) +
                             np.sum(scatter_stats.pillar_specular)) / total
         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{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:
+        info.extend([
+                    f'\n{sc_on_pill:.2f}% - scattering on pillar walls ',
+                    f'({sc_on_pill_diff:.2f}% - diffuse, ',
+                    f'{sc_on_pill_spec:.2f}% - specular)']
+                    )
+
+    if cf. interfaces:
+        sc_on_interf = 100*(np.sum(scatter_stats.interfaces_diffuse) +
+                             np.sum(scatter_stats.interfaces_specular)) / total
+        sc_on_interf_diff = 100*np.sum(scatter_stats.interfaces_diffuse) / total_interf
+        sc_on_interf_spec = 100*np.sum(scatter_stats.interfaces_specular) / total_interf
+        info.extend([
+                    f'\n{sc_on_interf:.2f}% - scattering on interfaces ',
+                    f'({sc_on_interf_diff:.2f}% - diffuse, ',
+                    f'{sc_on_interf_spec:.2f}% - specular)']
+                    )
+
+    # Write the file:
     with open("Information.txt", "a", encoding="utf-8") as file:
-        file.writelines(info1)
-        if cf.holes:
-            file.writelines(info2)
-        if cf.pillars:
-            file.writelines(info3)
+        file.writelines(info)
 
 
 def output_parameter_warnings():

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

@@ -9,7 +9,7 @@ from matplotlib.colors import LogNorm
 from matplotlib import font_manager
 
 from freepaths.config import cf
-from freepaths.output_structure import draw_structure
+from freepaths.output_structure import draw_structure_top_view, draw_structure_side_view
 from freepaths.materials import Si, SiC, Graphite
 import matplotlib.pyplot as plt
 
@@ -384,8 +384,8 @@ def plot_trajectories():
     # Create XY plot:
     fig, ax = plt.subplots()
 
-    # Draw structures:
-    patches = draw_structure(cf, color_holes='white', color_back=cf.output_structure_color)
+    # Draw structure:
+    patches = draw_structure_top_view(cf, color_holes='white', color_back=cf.output_structure_color)
     for patch in patches:
         ax.add_patch(patch)
 
@@ -405,6 +405,12 @@ def plot_trajectories():
 
     # Create YZ plot:
     fig, ax = plt.subplots()
+
+    # Draw structure:
+    patches = draw_structure_side_view(cf, color_holes='white', color_back=cf.output_structure_color)
+    for patch in patches:
+        ax.add_patch(patch)
+
     for index in range(cf.output_trajectories_of_first):
         y_coordinates = np.trim_zeros(data[:, 3 * index + 1], trim='b')
         num_of_points = len(y_coordinates)
@@ -465,7 +471,7 @@ def plot_structure():
     fig, ax = plt.subplots()
 
     # Draw structures:
-    patches = draw_structure(cf, color_holes='black', color_back='royalblue')
+    patches = draw_structure_top_view(cf, color_holes='black', color_back='royalblue')
     for patch in patches:
         ax.add_patch(patch)
 

{freepaths-2.0 → freepaths-2.1}/freepaths/output_structure.py

@@ -2,8 +2,9 @@
 
 from matplotlib.patches import Rectangle
 from freepaths.config import cf
+from freepaths.scatterers import HorizontalPlane, VerticalPlane
 
-def draw_structure(cf, color_holes="white", color_back="gray"):
+def draw_structure_top_view(cf, color_holes="white", color_back="gray"):
     """Draw shape of the structure using patches from matplotlib"""
 
     # Overal shape as gray area:
@@ -26,6 +27,12 @@ def draw_structure(cf, color_holes="white", color_back="gray"):
         patch = pillar.get_patch(color_holes, cf)
         patches.extend(patch if isinstance(patch, list) else [patch])
 
+    # Interfaces as white patches:
+    for interface in cf.interfaces:
+        if isinstance(interface, VerticalPlane):
+            patch = interface.get_patch(color_holes, cf)
+            patches.extend(patch if isinstance(patch, list) else [patch])
+
     # Phonon source areas as red patches:
     for source in cf.phonon_sources:
         width_x = 1e6 * cf.width / 49 if source.size_x == 0 else 1e6 * source.size_x
@@ -38,3 +45,25 @@ def draw_structure(cf, color_holes="white", color_back="gray"):
         patches.append(phonon_source_patch)
 
     return patches
+
+
+def draw_structure_side_view(cf, color_holes="white", color_back="gray"):
+    """Draw shape of the structure using patches from matplotlib"""
+
+    # Overal shape as gray area:
+    patches = [
+        Rectangle(
+            (0, -1e6 * cf.thickness/2),
+            1e6 * cf.length,
+            1e6 * cf.thickness,
+            facecolor=color_back,
+        )
+    ]
+
+    # Interfaces as white patches:
+    for interface in cf.interfaces:
+        if isinstance(interface, HorizontalPlane):
+            patch = interface.get_patch(color_holes, cf)
+            patches.extend(patch if isinstance(patch, list) else [patch])
+
+    return patches

freepaths-2.0/freepaths/holes.py → freepaths-2.1/freepaths/scatterers.py

@@ -6,6 +6,7 @@ These classes contain all methods associated with scattering on holes.
 
 from math import atan
 from numpy import pi, array, linspace, column_stack, vstack
+from random import random
 from matplotlib.patches import Rectangle, Circle, Polygon
 from scipy.spatial import cKDTree
 
@@ -75,23 +76,31 @@ class CircularHole(Hole):
 class RectangularHole(Hole):
     """Shape of a rectangular hole"""
 
-    def __init__(self, x=0, y=0, size_x=100e-9, size_y=100e-9):
+    def __init__(self, x=0, y=0, size_x=100e-9, size_y=100e-9, depth=None):
         self.x0 = x
         self.y0 = y
         self.size_x = size_x
         self.size_y = size_y
+        self.depth = depth
 
     def is_inside(self, x, y, z, cf):
-        """Check if phonon with given coordinates traverses the boundary"""
-        return (abs(x - self.x0) <= self.size_x / 2) and (abs(y - self.y0) <= self.size_y / 2)
+        """Check if phonon with given coordinates traverses the boundary. It also depens on in the hole is complete or partial."""
+        if self.depth and z:
+            return (abs(x - self.x0) <= self.size_x / 2) and (abs(y - self.y0) <= self.size_y / 2) and (z > cf.thickness/2 - self.depth)
+        else:
+            return (abs(x - self.x0) <= self.size_x / 2) and (abs(y - self.y0) <= self.size_y / 2)
+
 
     def scatter(self, ph, scattering_types, x, y, z, cf):
         """Calculate the new direction after scattering on the hole"""
 
-        # Coordinate y of the intersection with the hole side:
-        y1 = (self.y0 - y) + cos(ph.theta) * (
-            self.size_x / 2 - abs(self.x0 - x)
-        ) / abs(sin(ph.theta))
+        # If phonon arrives from below, then it's bottom scattering:
+        if self.depth and ph.z < (cf.thickness/2 - self.depth):
+            scattering_types.holes = in_plane_surface_scattering(ph, cf.top_roughness)
+            return
+
+        # Otherwise, calculate coordinate y of the intersection with the hole side:
+        y1 = (self.y0 - y) + cos(ph.theta) * (self.size_x / 2 - abs(self.x0 - x)) / abs(sin(ph.theta))
 
         # Scattering on the left wall:
         if abs(y1) <= self.size_y / 2 and x < self.x0:
@@ -611,3 +620,104 @@ class CircularPillar():
     def get_patch(self, color_holes, cf):
         """Create a patch in the shape of the hole to use in the plots"""
         return Circle((1e6 * self.x0, 1e6 * self.y0), 1e6 * self.diameter / 2, facecolor=color_holes,)
+
+
+class Interface:
+    def is_crossed(self, ph, x, y, z) -> bool:
+        """
+        Check if phonon with given coordinates traverses the plane.
+        It returns True or False depending whether x, y, z are on the other side.
+        """
+        pass
+
+    def scatter(self, ph, scattering_types, x, y, z, cf):
+        """
+        Calculate the new direction after scattering on the interface wall.
+        It returns ScatteringTypes object with the scattering type that occured.
+        """
+        pass
+
+    def is_transmitted(self) -> bool:
+        """
+        Check if phonon transmitted without scattering, taking into account the probability.
+        It return True if transmission occured or False if it must scatter.
+        """
+        pass
+
+    def get_patch(self, color_holes, cf):
+        """
+        Create a patch in the shape of a thin line to use in the plots.
+        It returns the matplotlib.patches objects like Rectangle etc.
+        """
+        pass
+
+
+class VerticalPlane(Interface):
+    """Vertical plane that represents an interface"""
+
+    def __init__(self, position_x=0, transmission=0):
+        self.position_x = position_x
+        self.transmission = transmission
+
+    def is_crossed(self, ph, x, y, z):
+        """Check if phonon with traverses the vertical plane at given coordinate"""
+        return (ph.x < self.position_x < x) or (ph.x > self.position_x > x)
+
+    def is_transmitted(self):
+        """Check if phonon traverses the plane given the transmission probability"""
+        return random() < self.transmission
+
+    def scatter(self, ph, scattering_types, x, y, z, cf):
+        """Calculate the new direction after scattering on the interface wall"""
+
+        # Scattering on the left wall:
+        if x < self.position_x:
+            scattering_types.interfaces = vertical_surface_left_scattering(ph, cf.interface_roughness, cf)
+
+        # Scattering on the right wall:
+        else:
+            scattering_types.interfaces = vertical_surface_right_scattering(ph, cf.interface_roughness, cf)
+
+    def get_patch(self, color_holes, cf):
+        """Create a patch in the shape of a thin line to use in the plots"""
+        return Rectangle(
+            (1e6 * self.position_x, 0),
+            1e6 * 0.005*cf.width, 1e6 * cf.length,
+            facecolor=color_holes,
+        )
+
+
+
+class HorizontalPlane(Interface):
+    """Horizontal plane that represents an interface"""
+
+    def __init__(self, position_z=0, transmission=0):
+        self.position_z = position_z
+        self.transmission = transmission
+
+    def is_crossed(self, ph, x, y, z):
+        """Check if phonon with traverses the vertical plane at given coordinate"""
+        return (ph.z < self.position_z < z) or (ph.z > self.position_z > z)
+
+    def is_transmitted(self):
+        """Check if phonon traverses the plane given the transmission probability"""
+        return random() < self.transmission
+
+    def scatter(self, ph, scattering_types, x, y, z, cf):
+        """Calculate the new direction after scattering on the interface wall"""
+
+        # Scattering on the left wall:
+        if x < self.position_z:
+            scattering_types.interfaces = horizontal_surface_up_scattering(ph, cf.interface_roughness, cf)
+
+        # Scattering on the right wall:
+        else:
+            scattering_types.interfaces = horizontal_surface_down_scattering(ph, cf.interface_roughness, cf)
+
+    def get_patch(self, color_holes, cf):
+        """Create a patch in the shape of a thin line to use in the plots"""
+        return Rectangle(
+            (0, 1e6 * self.position_z),
+            1e6 * cf.length, 1e6 * 0.005*cf.thickness,
+            facecolor=color_holes,
+        )

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

@@ -23,56 +23,40 @@ def reinitialization(ph, scattering_types):
     x, y, _ = move(ph, cf.timestep)
 
     if cf.hot_side_position_bottom and y < 0:
-        scattering_types.hot_side = horizontal_surface_up_scattering(
-            ph, cf.side_wall_roughness, is_diffuse=True
-        )
+        scattering_types.hot_side = horizontal_surface_up_scattering(ph, cf.side_wall_roughness, is_diffuse=True)
 
     if cf.hot_side_position_top and y > cf.length:
-        scattering_types.hot_side = horizontal_surface_down_scattering(
-            ph, cf.side_wall_roughness, is_diffuse=True
-        )
+        scattering_types.hot_side = horizontal_surface_down_scattering(ph, cf.side_wall_roughness, is_diffuse=True)
 
     if cf.hot_side_position_right and x > cf.width / 2:
-        scattering_types.hot_side = vertical_surface_left_scattering(
-            ph, cf.side_wall_roughness, cf, is_diffuse=True
-        )
+        scattering_types.hot_side = vertical_surface_left_scattering(ph, cf.side_wall_roughness, cf, is_diffuse=True)
 
     if cf.hot_side_position_left and x < -cf.width / 2:
-        scattering_types.hot_side = vertical_surface_right_scattering(
-            ph, cf.side_wall_roughness, cf, is_diffuse=True
-        )
+        scattering_types.hot_side = vertical_surface_right_scattering(ph, cf.side_wall_roughness, cf, is_diffuse=True)
 
 
 def scattering_on_right_sidewall(ph, scattering_types, x, y, z):
     """Scatter phonon if it reached right side wall"""
     if x > cf.width / 2:
-        scattering_types.walls = vertical_surface_left_scattering(
-            ph, cf.side_wall_roughness, cf
-        )
+        scattering_types.walls = vertical_surface_left_scattering(ph, cf.side_wall_roughness, cf)
 
 
 def scattering_on_left_sidewall(ph, scattering_types, x, y, z):
     """Scatter phonon if it reached left side wall"""
     if x < -cf.width / 2:
-        scattering_types.walls = vertical_surface_right_scattering(
-            ph, cf.side_wall_roughness, cf
-        )
+        scattering_types.walls = vertical_surface_right_scattering(ph, cf.side_wall_roughness, cf)
 
 
 def scattering_on_top_sidewall(ph, scattering_types, x, y, z):
     """Check if the phonon hits top side wall and output new vector"""
     if y > cf.length:
-        scattering_types.walls = horizontal_surface_down_scattering(
-            ph, cf.side_wall_roughness
-        )
+        scattering_types.walls = horizontal_surface_down_scattering(ph, cf.side_wall_roughness)
 
 
 def scattering_on_bottom_sidewall(ph, scattering_types, x, y, z):
     """Check if the phonon hits bottom side wall and output new vector"""
     if y < 0.0:
-        scattering_types.walls = horizontal_surface_up_scattering(
-            ph, cf.side_wall_roughness
-        )
+        scattering_types.walls = horizontal_surface_up_scattering(ph, cf.side_wall_roughness)
 
 
 def floor_scattering(ph, scattering_types, x, y, z):
@@ -93,15 +77,11 @@ def ceiling_scattering(ph, scattering_types, x, y, z):
             is_under_pillar = distance_from_pillar_center < pillar.diameter / 2
             if is_under_pillar:
                 if z > pillar.height + cf.thickness / 2:
-                    scattering_types.top_bottom = in_plane_surface_scattering(
-                        ph, cf.top_roughness
-                    )
+                    scattering_types.top_bottom = in_plane_surface_scattering(ph, cf.top_roughness)
                 return
         # Regular scattering if phonon is not under any of the pillars:
         if ph.z < cf.thickness / 2:
-            scattering_types.top_bottom = in_plane_surface_scattering(
-                ph, cf.top_roughness
-            )
+            scattering_types.top_bottom = in_plane_surface_scattering(ph, cf.top_roughness)
 
     else:
         scattering_types.top_bottom = in_plane_surface_scattering(ph, cf.top_roughness)
@@ -147,5 +127,11 @@ def surface_scattering(ph, scattering_types, triangle_scattering_places):
             if scattering_types.pillars is not None:
                 break
 
+    # Scattering on interfaces:
+    if cf.interfaces:
+        for interface in cf.interfaces:
+            if interface.is_crossed(ph, x, y, z) and interface.is_transmitted():
+                interface.scatter(ph, scattering_types, x, y, z, cf)
+
     # Correct angle if it became more than 180 degrees:
     ph.correct_angle()

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

@@ -24,6 +24,7 @@ class ScatteringTypes:
         self.walls = None
         self.internal = None
         self.hot_side = None
+        self.interfaces = None
 
     @property
     def is_diffuse(self):
@@ -32,7 +33,8 @@ class ScatteringTypes:
                     self.pillars == Scattering.DIFFUSE,
                     self.top_bottom == Scattering.DIFFUSE,
                     self.walls == Scattering.DIFFUSE,
-                    self.hot_side == Scattering.DIFFUSE])
+                    self.hot_side == Scattering.DIFFUSE,
+                    self.interfaces == Scattering.DIFFUSE])
 
     @property
     def is_internal(self):
@@ -57,7 +59,8 @@ class ScatteringTypes:
                     self.top_bottom,
                     self.walls,
                     self.internal,
-                    self.hot_side])
+                    self.hot_side,
+                    self.interfaces])
 
     def reset(self):
         """Reset all scattering types to None"""
@@ -67,6 +70,7 @@ class ScatteringTypes:
         self.walls = None
         self.internal = None
         self.hot_side = None
+        self.interfaces = None
 
 
 class ScatteringPlaces:

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: freepaths
-Version: 2.0
+Version: 2.1
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -11,18 +11,28 @@ Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Environment :: Console
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
-Requires-Python: ~=3.8
+Requires-Python: ~=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: imageio
 Requires-Dist: colorama
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # FreePATHS - Free Phonon And Thermal Simulator
 

{freepaths-2.0 → freepaths-2.1}/freepaths.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ freepaths/config.py
 freepaths/data.py
 freepaths/default_config.py
 freepaths/flight.py
-freepaths/holes.py
 freepaths/main_mfp_sampling.py
 freepaths/main_tracing.py
 freepaths/maps.py
@@ -19,6 +18,7 @@ freepaths/output_structure.py
 freepaths/phonon.py
 freepaths/progress.py
 freepaths/run_phonon.py
+freepaths/scatterers.py
 freepaths/scattering.py
 freepaths/scattering_primitives.py
 freepaths/scattering_semicircle.py

{freepaths-2.0 → freepaths-2.1}/setup.py

@@ -25,17 +25,17 @@ setuptools.setup(
     },
     install_requires=['numpy', 'matplotlib', 'scipy', 'imageio', 'colorama'],
     version=version,
-    python_requires='~=3.8',
+    python_requires='~=3.11',
     classifiers=[
         "Development Status :: 4 - Beta",
         "License :: OSI Approved :: GNU General Public License (GPL)",
         "Environment :: Console",
         "Natural Language :: English",
         "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Topic :: Utilities",
     ],
     packages=["freepaths"],