freepaths 2.1.3__tar.gz → 2.2__tar.gz

{freepaths-2.1.3 → freepaths-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.1.3
+Version: 2.2
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -95,7 +95,7 @@ The code is still in development and provided as is. It likely contains bugs or
 
 ## References and acknowledgments
 
-The code is developed by [Roman Anufriev](https://anufrievroman.com), Philipp Gassmann, and other contributors in [Nomura lab](https://www.nlab.iis.u-tokyo.ac.jp/index-e.html) at the University of Tokyo since 2018.
+The code is developed by [Roman Anufriev](https://anufrievroman.com), Philipp Gassmann, Simon Defradas and other contributors in [Nomura lab](https://www.nlab.iis.u-tokyo.ac.jp/index-e.html) at the University of Tokyo since 2018.
 If you would like to use this code for your research, please see the disclaimer above and consider citing the papers below, if it is appropriate.
 Details of the code and examples of the output can be found in the following papers:
 

{freepaths-2.1.3 → freepaths-2.2}/README.md

@@ -59,7 +59,7 @@ The code is still in development and provided as is. It likely contains bugs or
 
 ## References and acknowledgments
 
-The code is developed by [Roman Anufriev](https://anufrievroman.com), Philipp Gassmann, and other contributors in [Nomura lab](https://www.nlab.iis.u-tokyo.ac.jp/index-e.html) at the University of Tokyo since 2018.
+The code is developed by [Roman Anufriev](https://anufrievroman.com), Philipp Gassmann, Simon Defradas and other contributors in [Nomura lab](https://www.nlab.iis.u-tokyo.ac.jp/index-e.html) at the University of Tokyo since 2018.
 If you would like to use this code for your research, please see the disclaimer above and consider citing the papers below, if it is appropriate.
 Details of the code and examples of the output can be found in the following papers:
 

{freepaths-2.1.3 → freepaths-2.2}/freepaths/__main__.py

@@ -4,10 +4,8 @@ import argparse
 import colorama
 from colorama import Fore, Style
 
-import freepaths.main_tracing
-import freepaths.main_mfp_sampling
 
-__version__ = "2.1.3"
+__version__ = "2.2"
 
 colorama.init()
 
@@ -19,6 +17,7 @@ parser = argparse.ArgumentParser(
                 )
 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")
+parser.add_argument("-e", "--electron", help="Run simulation for electrons", action="store_true")
 args = parser.parse_args()
 
 
@@ -26,9 +25,18 @@ def run():
     """Run the program depending on the mode"""
     print(f"\n{Fore.BLUE}FreePATHS v{__version__}{Style.RESET_ALL}")
     if args.sampling:
+        import freepaths.main_mfp_sampling
         freepaths.main_mfp_sampling.main(args.input_file)
+
+    elif args.electron:
+        import freepaths.main_tracing
+        from freepaths.particle_types import ParticleType
+        freepaths.main_tracing.main(args.input_file, ParticleType.ELECTRON)
+
     else:
-        freepaths.main_tracing.main(args.input_file)
+        import freepaths.main_tracing
+        from freepaths.particle_types import ParticleType
+        freepaths.main_tracing.main(args.input_file, ParticleType.PHONON)
 
 
 if __name__ == "__main__":

{freepaths-2.1.3 → freepaths-2.2}/freepaths/config.py

@@ -6,6 +6,7 @@ checks the validity of the parameters and converts the variables into enums
 import sys
 import argparse
 import logging
+import builtins #24/06
 from colorama import Fore, Style
 
 from freepaths.sources import Distributions
@@ -24,6 +25,7 @@ parser = argparse.ArgumentParser(prog='FreePATHS', description='Monte Carlo simu
                                  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")
+parser.add_argument("-e", "--electron", help="Run with electrons", action="store_true")
 args = parser.parse_args()
 
 
@@ -46,13 +48,14 @@ class Config:
 
         # General parameters:
         self.output_folder_name = str(OUTPUT_FOLDER_NAME)
-        self.number_of_phonons = NUMBER_OF_PHONONS
+        self.number_of_particles = NUMBER_OF_PARTICLES
         self.number_of_nodes = NUMBER_OF_NODES
         self.temp = T
         self.output_scattering_map = OUTPUT_SCATTERING_MAP
         self.output_trajectories_of_first = OUTPUT_TRAJECTORIES_OF_FIRST
         self.output_structure_color = OUTPUT_STRUCTURE_COLOR
         self.number_of_length_segments = NUMBER_OF_LENGTH_SEGMENTS
+        self.low_memory_usage = LOW_MEMORY_USAGE
 
         # Time parameters:
         self.timestep = TIMESTEP
@@ -60,6 +63,14 @@ class Config:
         self.number_of_timeframes = NUMBER_OF_TIMEFRAMES
         self.number_of_stabilization_timeframes = NUMBER_OF_STABILIZATION_TIMEFRAMES
 
+        # Electron parameters:
+        self.energy_upper_bound = ENERGY_UPPER_BOUND
+        self.energy_lower_bound = ENERGY_LOWER_BOUND
+        self.energy_step = ENERGY_STEP
+        self.electron_mfp = ELECTRON_MFP
+        self.mean_mapping_constant = MEAN_MAPPING_CONSTANT
+        self.is_carrier_electron = IS_CARRIER_ELECTRON
+
         # Animation:
         self.output_path_animation = OUTPUT_PATH_ANIMATION
         self.output_animation_fps = OUTPUT_ANIMATION_FPS
@@ -68,10 +79,11 @@ class Config:
         self.number_of_pixels_x = NUMBER_OF_PIXELS_X
         self.number_of_pixels_y = NUMBER_OF_PIXELS_Y
         self.number_of_virtual_timesteps = NUMBER_OF_VIRTUAL_TIMESTEPS
-        self.ignore_faulty_phonons = IGNORE_FAULTY_PHONONS
+        self.ignore_faulty_particles = IGNORE_FAULTY_PARTICLES
 
         # Material parameters:
         self.media = MEDIA
+        self.media_fermi_level = MEDIA_FERMI_LEVEL
 
         # Internal scattering:
         self.include_internal_scattering = INCLUDE_INTERNAL_SCATTERING
@@ -96,7 +108,7 @@ class Config:
         self.rethermalization_on_hot_sides = RETHERMALIZATION_ON_HOT_SIDES
 
         # Sources:
-        self.phonon_sources = PHONON_SOURCES
+        self.particles_sources = PARTICLE_SOURCES
 
         # Cold side positions:
         self.cold_side_position_top = COLD_SIDE_POSITION_TOP
@@ -117,6 +129,7 @@ class Config:
         self.holes = HOLES
         self.pillars = PILLARS
         self.interfaces = INTERFACES
+        self.bulks = BULKS
 
         # Multiprocessing:
         self.num_workers = NUMBER_OF_PROCESSES
@@ -126,7 +139,7 @@ class Config:
 
         # Distributions:
         valid_distributions =[member.name.lower() for member in Distributions]
-        for source in self.phonon_sources:
+        for source in self.particles_sources:
             if source.angle_distribution in valid_distributions:
                 source.angle_distribution = Distributions[source.angle_distribution.upper()]
             else:
@@ -136,8 +149,8 @@ class Config:
 
     def check_parameter_validity(self):
         """Check if various parameters are valid"""
-        if self.number_of_phonons < self.output_trajectories_of_first:
-            self.output_trajectories_of_first = self.number_of_phonons
+        if self.number_of_particles < self.output_trajectories_of_first:
+            self.output_trajectories_of_first = self.number_of_particles
 
         if self.number_of_timeframes <= self.number_of_stabilization_timeframes:
             logging.error("Parameter NUMBER_OF_STABILIZATION_TIMEFRAMES exceeds or equal to NUMBER_OF_TIMEFRAMES.\n" +
@@ -145,7 +158,7 @@ class Config:
                           f"See the documentation at {WEBSITE}")
             sys.exit()
 
-        for source in self.phonon_sources:
+        for source in self.particles_sources:
             if source.y > self.length:
                 logging.error("Y coordinate of a source exceeded LENGHT")
                 sys.exit()
@@ -232,7 +245,18 @@ class Config:
                           f"See the documentation at {WEBSITE}")
             sys.exit()
 
+        if any([
+            'NUMBER_OF_PHONONS' in globals(),
+            'IGNORE_FAULTY_PHONONS' in globals(),
+            'PHONON_SOURCES' in globals(),
+        ]):
+            logging.error("Parameters NUMBER_OF_PHONONS, PHONON_SOURCES and IGNORE_FAULTY_PHONONS were deprecated.\n" +
+                          "Replace PHONONS with PARTICLES.\n" +
+                          f"See the documentation at {WEBSITE}")
+            sys.exit()
+
 cf = Config()
 cf.convert_to_enums()
 cf.check_parameter_validity()
 cf.check_depricated_parameters()
+

{freepaths-2.1.3 → freepaths-2.2}/freepaths/data.py

@@ -15,26 +15,30 @@ class Data:
 
 
 class PathData(Data):
-    """Paths of phonons in space"""
+    """Paths of particles in space"""
 
     def __init__(self):
-        """Initialize arrays to save phonon paths"""
-        self.phonon_paths = []
+        """Initialize arrays to save particle paths"""
+        self.particle_paths = []
 
-    def save_phonon_path(self, flight):
+    def save_particle_path(self, flight):
         """Save the path to list of all paths"""
-        self.phonon_paths.append(flight.path)
+        if cf.low_memory_usage:
+            return
+        self.particle_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])
+        return max([path.number_of_path_points for path in self.particle_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):
+        if cf.low_memory_usage:
+            return
+        filename = "Data/Particle paths.csv"
+        data = np.zeros((self.length_of_longest_path, 3*len(self.particle_paths)))
+        for index, path in enumerate(self.particle_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
@@ -43,11 +47,11 @@ class PathData(Data):
 
     def dump_data(self):
         """Return data of a process in the form of a dictionary to be attached to the global data"""
-        return {'phonon_paths': self.phonon_paths}
+        return {'particle_paths': self.particle_paths}
 
 
 class GeneralData(Data):
-    """General statistics of various phonon properties"""
+    """General statistics of various particle properties"""
 
     def __init__(self):
         """Initialize arrays for writing various properties"""
@@ -56,34 +60,50 @@ class GeneralData(Data):
         self.hole_diff_scattering_angles = []
         self.hole_spec_scattering_angles = []
         self.free_paths = []
-        self.free_paths_along_y = []
         self.frequencies = []
+        self.initial_energies = []
         self.group_velocities = []
         self.travel_times = []
         self.mean_free_paths = []
         self.thermal_conductivity = []
-
-    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)
+        self.interfaces_angles = []
+        self.interfaces_transmission_factor = []
+        self.interfaces_wavelength = []
+        self.interfaces_frequency = []
+        self.interfaces_mode = []
+
+    def save_particle_data(self, pt):
+        """Add information about the particle to the dataset"""
+        self.frequencies.append(pt.f)
+        self.group_velocities.append(pt.speed)
+        self.initial_energies.append(pt.energy)
 
     def save_flight_data(self, flight):
-        """Add information about the phonon flight to the dataset"""
+        """Add information about the particle flight to the dataset"""
+        if not cf.low_memory_usage:
+            self.free_paths.extend(flight.free_paths)
         self.initial_angles.append(flight.initial_theta)
         self.exit_angles.append(flight.exit_theta)
-        self.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)
         self.thermal_conductivity.append(flight.thermal_conductivity)
+        self.interfaces_angles.extend(flight.interfaces_angles)
+        self.interfaces_transmission_factor.extend(flight.interfaces_transmission_factor)
+        self.interfaces_wavelength.extend(flight.interfaces_wavelength)
+        self.interfaces_frequency.extend(flight.interfaces_frequency)
+        self.interfaces_mode.extend(flight.interfaces_mode)
+
+
 
     def write_into_files(self):
+        import os
+        if not os.path.exists("Data"):
+            os.makedirs("Data")
         """Write all the data into files"""
-        np.savetxt("Data/All free paths.csv", self.free_paths, fmt='%2.4e', header="L [m]", encoding='utf-8')
-        np.savetxt("Data/All free paths in plane.csv", self.free_paths_along_y, fmt='%2.4e', header="Ly [m]", encoding='utf-8')
+        if not cf.low_memory_usage:
+            np.savetxt("Data/All free paths.csv", self.free_paths, fmt='%2.4e', header="L [m]", encoding='utf-8')
         np.savetxt("Data/All initial frequencies.csv", self.frequencies, fmt='%2.4e', header="f [Hz]", encoding='utf-8')
         np.savetxt("Data/All exit angles.csv", self.exit_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
         np.savetxt("Data/All hole diffuse scattering angles.csv", self.hole_diff_scattering_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
@@ -93,6 +113,12 @@ class GeneralData(Data):
         np.savetxt("Data/All travel times.csv", self.travel_times, fmt='%2.4e', header="Travel time [s]", encoding='utf-8')
         np.savetxt("Data/All mean free paths.csv", self.mean_free_paths, fmt='%2.4e', header="MFPs [m]", encoding='utf-8')
         np.savetxt("Data/All thermal conductivities.csv", self.thermal_conductivity, fmt='%2.4e', header="K [W/mK]", encoding='utf-8')
+        np.savetxt("Data/All initial energies.csv", self.initial_energies, fmt='%2.4e', header="Energy [J]", encoding='utf-8')
+        np.savetxt("Data/All interfaces angles.csv", self.interfaces_angles, fmt='%.4f', header="Angle [rad]", encoding='utf-8')
+        np.savetxt("Data/All interfaces transmission factor.csv", self.interfaces_transmission_factor, fmt='%2.4e', header="Transmission factor [%]", encoding='utf-8')
+        np.savetxt("Data/All interfaces wavelength.csv", self.interfaces_wavelength, fmt='%.18f', header="Interfaces wavelength [m]", encoding='utf-8')
+        np.savetxt("Data/All interfaces frequency.csv", self.interfaces_frequency, fmt='%.18f', header="Interfaces frequency [THz]", encoding='utf-8')
+        np.savetxt("Data/All interfaces mode.csv", self.interfaces_mode, fmt='%d', header="Interfaces mode", encoding='utf-8')
 
     def dump_data(self):
         """Return data of a process in the form of a dictionary to be attached to the global data"""
@@ -102,17 +128,23 @@ class GeneralData(Data):
             '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,
             'group_velocities': self.group_velocities,
             'travel_times': self.travel_times,
             'mean_free_paths': self.mean_free_paths,
             'thermal_conductivity': self.thermal_conductivity,
+            'initial_energies': self.initial_energies,
+            'interfaces_angles': self.interfaces_angles,
+            'interfaces_transmission_factor': self.interfaces_transmission_factor,
+            'interfaces_wavelength': self.interfaces_wavelength,
+            'interfaces_frequency': self.interfaces_frequency,
+            'interfaces_mode': self.interfaces_mode,
         }
 
 
+
 class ScatteringData(Data):
-    """Statistics of phonon scattering events"""
+    """Statistics of particle scattering events"""
 
     def __init__(self):
         """Initialize arrays according to the number of segments"""
@@ -129,6 +161,15 @@ class ScatteringData(Data):
         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)
+        self.interfaces_transmission_specular= np.zeros(cf.number_of_length_segments + 1)
+        self.interfaces_transmission_diffuse = np.zeros(cf.number_of_length_segments + 1)
+        self.interfaces_angles = np.zeros(cf.number_of_length_segments + 1)
+        self.interfaces_transmission_factor = np.zeros(cf.number_of_length_segments + 1)
+        self.interfaces_wavelength = np.zeros(cf.number_of_length_segments+1)
+        self.interfaces_frequency = np.zeros(cf.number_of_length_segments+1)
+        self.interfaces_mode = np.zeros(cf.number_of_length_segments+1)
+
+
 
     def save_scattering_events(self, y, scattering_types):
         """Analyze types of scattering at the current timestep and add it to the statistics"""
@@ -161,6 +202,10 @@ class ScatteringData(Data):
             # 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
+
+            # Interfaces transmission events:
+            self.interfaces_transmission_specular[segment] += 1 if scattering_types.interfaces_transmission== Scattering.SPECULAR else 0
+            self.interfaces_transmission_diffuse[segment] += 1 if scattering_types.interfaces_transmission == Scattering.DIFFUSE else 0
         except:
             pass
 
@@ -168,10 +213,16 @@ class ScatteringData(Data):
         """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
+                        self.hole_specular, self.hot_side, self.internal, self.pillar_diffuse, self.pillar_specular,
+                        self.interfaces_diffuse, self.interfaces_specular,
+                        self.interfaces_transmission_diffuse, self.interfaces_transmission_specular,
+                        self.interfaces_transmission_factor, self.interfaces_angles,
+                        self.interfaces_wavelength, self.interfaces_mode)).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
+        header3 = "Interfaces diffuse, Interfaces specular, Interfaces transmission diffuse, Interfaces transmission specular, " \
+        "Interfaces transmission factor, Interfaces angles, Interfaces wavelength, Interfaces frequency, Interfaces mode"
+        header = header1 + header2 + header3
         np.savetxt(filename, data, fmt='%1.3e', delimiter=",", header=header, encoding='utf-8')
 
     def dump_data(self):
@@ -189,12 +240,19 @@ class ScatteringData(Data):
             'internal': self.internal,
             'interfaces_diffuse': self.interfaces_diffuse,
             'interfaces_specular': self.interfaces_specular,
+            'interfaces_transmission_specular': self.interfaces_transmission_specular,
+            'interfaces_transmission_diffuse': self.interfaces_transmission_diffuse,
+            'interfaces_angles': self.interfaces_angles,
+            'interfaces_transmission_factor': self.interfaces_transmission_factor,
+            'interfaces_wavelength': self.interfaces_wavelength,
+            'interfaces_frequency': self.interfaces_frequency,
+            'interfaces_mode' : self.interfaces_mode,
             'total': self.total
         }
 
 
 class TriangleScatteringData(Data):
-    """Statistics of phonon scattering events on triangular holes"""
+    """Statistics of particle scattering events on triangular holes"""
 
     def __init__(self):
         """Initialize arrays according to the number of segments"""
@@ -255,7 +313,7 @@ class SegmentData(Data):
         return segments
 
     def record_time_in_segment(self, coordinate):
-        """Record how long phonon stays in different segments"""
+        """Record how long particle stays in different segments"""
         for segment_number in range(cf.number_of_length_segments):
             segment_beginning = segment_number * (cf.length / cf.number_of_length_segments)
             segment_end = (segment_number + 1)*(cf.length / cf.number_of_length_segments)

{freepaths-2.1.3 → freepaths-2.2}/freepaths/default_config.py

@@ -1,18 +1,20 @@
 """Default config file"""
 
 import numpy as np
+from scipy.constants import k, electron_volt
 from freepaths.sources import Source
 
 
 # General parameters:
 OUTPUT_FOLDER_NAME               = "Si nanowire at 300 K"
-NUMBER_OF_PHONONS                = 5000
+NUMBER_OF_PARTICLES              = 5000
 NUMBER_OF_NODES                  = 400
 T                                = 300
 OUTPUT_SCATTERING_MAP            = False
 OUTPUT_TRAJECTORIES_OF_FIRST     = 50
 OUTPUT_STRUCTURE_COLOR           = "#F0F0F0"
 NUMBER_OF_LENGTH_SEGMENTS        = 10
+LOW_MEMORY_USAGE                 = False
 
 # Time parameters:
 TIMESTEP                         = 1e-12
@@ -21,6 +23,15 @@ NUMBER_OF_VIRTUAL_TIMESTEPS      = NUMBER_OF_TIMESTEPS * 3
 NUMBER_OF_TIMEFRAMES             = 8
 NUMBER_OF_STABILIZATION_TIMEFRAMES = 5
 
+# Electron parameters [eV]
+IS_CARRIER_ELECTRON              = True
+ENERGY_UPPER_BOUND               = 3*k*T / electron_volt
+ENERGY_LOWER_BOUND               = 0
+ENERGY_STEP                      = 5e-3
+
+ELECTRON_MFP                     = 15e-9 # [m]
+MEAN_MAPPING_CONSTANT            = 5e-6 # [m²]
+
 
 # Animation:
 OUTPUT_PATH_ANIMATION            = False
@@ -29,10 +40,11 @@ OUTPUT_ANIMATION_FPS             = 24
 # Map & profiles parameters:
 NUMBER_OF_PIXELS_X               = 25
 NUMBER_OF_PIXELS_Y               = 100
-IGNORE_FAULTY_PHONONS            = False
+IGNORE_FAULTY_PARTICLES          = False
 
 # Material parameters:
 MEDIA                            = "Si"
+MEDIA_FERMI_LEVEL                = None
 
 # Internal scattering:
 INCLUDE_INTERNAL_SCATTERING      = True
@@ -60,8 +72,8 @@ HOT_SIDE_POSITION_RIGHT          = False
 HOT_SIDE_POSITION_LEFT           = False
 RETHERMALIZATION_ON_HOT_SIDES    = True
 
-# Phonon source:
-PHONON_SOURCES = [Source(x=0, y=0, z=0, size_x=0,  size_y=0, size_z=0, angle_distribution="random", angle=0)]
+# Particle source:
+PARTICLE_SOURCES = [Source(x=0, y=0, z=0, size_x=0,  size_y=0, size_z=0, angle_distribution="random", angle=0)]
 
 # Roughness [m]:
 SIDE_WALL_ROUGHNESS              = 2e-9
@@ -76,6 +88,7 @@ INTERFACE_ROUGHNESS              = 0.2e-9
 HOLES                            = []
 PILLARS                          = []
 INTERFACES                       = []
+BULKS                            = [] 
 
 # Multiprocessing:
 NUMBER_OF_PROCESSES              = 10

freepaths-2.2/freepaths/electron.py

@@ -0,0 +1,77 @@
+"""This module provides electron class which generates and moves an electron"""
+
+from random import choice
+from scipy.constants import h, electron_volt
+from freepaths.config import cf
+from freepaths.particle import Particle
+from freepaths.particle_types import ParticleType
+
+import numpy as np
+
+class Electron(Particle):
+    """An electron particle"""
+
+    def __init__(self, material):
+        super().__init__()
+
+        # Assign particle type
+        self.type = ParticleType.ELECTRON
+        self.is_electron_carrier = cf.is_carrier_electron # assign electron or hole behavior
+
+        source = choice(cf.particles_sources)
+        while True:
+            self.x, self.y, self.z = source.generate_coordinates()
+            is_in_hole = any(hole.is_inside(self.x, self.y, None, cf) for hole in cf.holes)
+            if not is_in_hole:
+                break
+
+        # Assign initial angles
+        self.theta, self.phi = source.generate_angles()
+        self.correct_angle()
+        if cf.is_two_dimensional_material:
+            self.phi, self.z = 0.0, 0.0
+
+        self.assign_energy()
+        self.assign_frequency(material)
+        self.assign_speed(material)
+        self.assign_internal_scattering_time(material)
+
+    def assign_energy(self):
+        """
+        Assign energy uniformly to an electron based on temperature.
+        Conduction minimum is considered at 0 energy by convention.
+        """
+        num_energy_points = int((cf.energy_upper_bound-cf.energy_lower_bound)/cf.energy_step)
+        # Keep energy in J for other computations
+        self.energy = np.random.choice(np.linspace(cf.energy_lower_bound, cf.energy_upper_bound - cf.energy_step, num_energy_points)) * electron_volt + cf.energy_step * electron_volt
+
+
+    @property
+    def wavelength(self):
+        raise Exception("Electron wavelength undefined")
+
+    def assign_frequency(self, material):
+        """
+        Conduction minimum is 0 by convention
+        """
+        self.f = self.energy / h
+
+    def assign_speed(self, material):
+        """
+        Assign speed to an electron using group velocity and considering parabolic energy-k relation and conduction minimum at 0
+        """
+        if self.is_electron_carrier:
+            effective_mass = material.effective_electron_dos_mass
+        else:
+            effective_mass = material.effective_hole_dos_mass
+        self.speed = (2*self.energy/(effective_mass))**(0.5)
+
+    def assign_internal_scattering_time(self, material):
+        """
+        Determine relaxation time after which this particle will undergo internal scattering.
+        Considering only elasctic scattering between electrons and phonons and thus a constant MFP.
+        """
+        mfp = cf.electron_mfp
+        self.time_of_internal_scattering = mfp / self.speed
+
+        # self.time_of_internal_scattering = -np.log(random()) * (mfp/self.speed)