freepaths 2.2.4__tar.gz → 2.3.1__tar.gz

{freepaths-2.2.4 → freepaths-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.2.4
+Version: 2.3.1
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -54,9 +54,13 @@ FreePATHS is a command line application, so it runs inside Linux, MacOS, or Wind
 
 There are two modes of using the program. Main mode traces a large number of phonons through a structure and collects statistics about their paths. The MFP sampling mode measures phonon mean free paths using a small number of phonons and calculates the thermal conductivity by integrating phonon dispersion. 
 
-### Demo
+### Getting started
 
-If you simply run `freepaths` without specifying an input file, the program will run a demo simulation.
+If you run `freepaths` without any arguments, the program will print a usage summary. To run a demo simulation with default parameters, use the `--demo` flag:
+
+`freepaths --demo`
+
+Example input files are available in the [examples](https://github.com/anufrievroman/freepaths/tree/master/examples) folder.
 
 ### Main mode
 

{freepaths-2.2.4 → freepaths-2.3.1}/README.md

@@ -18,9 +18,13 @@ FreePATHS is a command line application, so it runs inside Linux, MacOS, or Wind
 
 There are two modes of using the program. Main mode traces a large number of phonons through a structure and collects statistics about their paths. The MFP sampling mode measures phonon mean free paths using a small number of phonons and calculates the thermal conductivity by integrating phonon dispersion. 
 
-### Demo
+### Getting started
 
-If you simply run `freepaths` without specifying an input file, the program will run a demo simulation.
+If you run `freepaths` without any arguments, the program will print a usage summary. To run a demo simulation with default parameters, use the `--demo` flag:
+
+`freepaths --demo`
+
+Example input files are available in the [examples](https://github.com/anufrievroman/freepaths/tree/master/examples) folder.
 
 ### Main mode
 

freepaths-2.3.1/freepaths/__main__.py

@@ -0,0 +1,64 @@
+"""FreePATHS - Free Phonon and THermal Simulator"""
+
+import sys
+import argparse
+import colorama
+from colorama import Fore, Style
+
+from freepaths.particle_types import ParticleType
+
+__version__ = "2.3.1"
+
+colorama.init()
+
+# Parse user arguments:
+parser = argparse.ArgumentParser(
+                prog = 'FreePATHS',
+                description = 'Phonon Monte Carlo simulator',
+                epilog = 'For more information, examples, and tutorials, visit: https://anufrievroman.gitbook.io/freepaths'
+                )
+parser.add_argument('input_file', nargs='?', default=None, help='The input file')
+parser.add_argument("-v", "--version", action="version", version=f"FreePATHS {__version__}")
+parser.add_argument("-s", "--sampling", help="Run in phonon MFP sampling mode", action="store_true")
+parser.add_argument("-e", "--electron", help="Run simulation for electrons", action="store_true")
+parser.add_argument("--demo", help="Run a demo simulation with default parameters", action="store_true")
+args = parser.parse_args()
+
+
+def run():
+    """Run the program depending on the mode"""
+    print(f"\n{Fore.BLUE}FreePATHS v{__version__}{Style.RESET_ALL}")
+
+    if not args.input_file and not args.demo:
+        print("\nUsage:")
+        print(f"  freepaths <input_file>              run phonon simulation")
+        print(f"  freepaths <input_file> -e           run electron simulation")
+        print(f"  freepaths <input_file> -s           run in MFP sampling mode")
+        print(f"  freepaths --demo                    run a demo with default parameters")
+        print(f"  freepaths --version                 show version")
+        print(f"\nExample input files:")
+        print(f"  https://github.com/anufrievroman/freepaths/tree/master/examples")
+        print(f"\nDocumentation:")
+        print(f"  https://anufrievroman.gitbook.io/freepaths")
+        sys.exit(0)
+
+    try:
+        if args.sampling:
+            import freepaths.main_mfp_sampling
+            freepaths.main_mfp_sampling.main(args.input_file, ParticleType.PHONON)
+
+        elif args.electron:
+            import freepaths.main_tracing
+            freepaths.main_tracing.main(args.input_file, ParticleType.ELECTRON)
+
+        else:
+            import freepaths.main_tracing
+            freepaths.main_tracing.main(args.input_file, ParticleType.PHONON)
+
+    except KeyboardInterrupt:
+        print(f"\n{Fore.RED}Simulation interrupted by user.{Style.RESET_ALL}")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    run()

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/config.py

@@ -26,6 +26,7 @@ parser = argparse.ArgumentParser(prog='FreePATHS', description='Monte Carlo simu
 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")
+parser.add_argument("--demo", help="Run a demo simulation with default parameters", action="store_true")
 args = parser.parse_args()
 
 
@@ -36,8 +37,6 @@ if args.input_file:
     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:")
 
 
 class Config:

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/data.py

@@ -204,10 +204,12 @@ class ScatteringData(Data):
     def write_into_files(self):
         """Write data into a file"""
         filename = "Data/Scattering events statistics.csv"
-        data = np.vstack((self.wall_diffuse, self.wall_specular, self.top_diffuse, self.top_specular, self.hole_diffuse,
-                        self.hole_specular, self.hot_side, self.internal, self.pillar_diffuse, self.pillar_specular,
-                        self.interfaces_diffuse, self.interfaces_specular,
-                        self.interfaces_transmission_diffuse, self.interfaces_transmission_specular)).T
+        n = cf.number_of_length_segments
+        data = np.vstack((self.wall_diffuse[:n], self.wall_specular[:n], self.top_diffuse[:n], self.top_specular[:n],
+                        self.hole_diffuse[:n], self.hole_specular[:n], self.hot_side[:n], self.internal[:n],
+                        self.pillar_diffuse[:n], self.pillar_specular[:n],
+                        self.interfaces_diffuse[:n], self.interfaces_specular[:n],
+                        self.interfaces_transmission_diffuse[:n], self.interfaces_transmission_specular[:n])).T
         header = ("Sidewalls diffuse, Sidewalls specular, Top & bottom diffuse, Top & bottom specular, "
                   "Holes diffuse, Holes specular, Hot side, Internal, Pillars diffuse, Pillars specular, "
                   "Interfaces diffuse, Interfaces specular, Interfaces transmission diffuse, Interfaces transmission specular")

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/default_config.py

@@ -7,18 +7,18 @@ from freepaths.sources import Source
 
 # General parameters:
 OUTPUT_FOLDER_NAME               = "Si nanowire at 300 K"
-NUMBER_OF_PARTICLES              = 5000
+NUMBER_OF_PARTICLES              = 10000
 NUMBER_OF_NODES                  = 400
 T                                = 300
 OUTPUT_SCATTERING_MAP            = False
-OUTPUT_TRAJECTORIES_OF_FIRST     = 50
+OUTPUT_TRAJECTORIES_OF_FIRST     = 20
 OUTPUT_STRUCTURE_COLOR           = "#F0F0F0"
 NUMBER_OF_LENGTH_SEGMENTS        = 10
 LOW_MEMORY_USAGE                 = False
 
 # Time parameters:
-TIMESTEP                         = 1e-12
-NUMBER_OF_TIMESTEPS              = 300000
+TIMESTEP                         = 2e-12
+NUMBER_OF_TIMESTEPS              = 200000
 NUMBER_OF_VIRTUAL_TIMESTEPS      = NUMBER_OF_TIMESTEPS * 3
 NUMBER_OF_TIMEFRAMES             = 8
 NUMBER_OF_STABILIZATION_TIMEFRAMES = 5
@@ -38,8 +38,8 @@ OUTPUT_PATH_ANIMATION            = False
 OUTPUT_ANIMATION_FPS             = 24
 
 # Map & profiles parameters:
-NUMBER_OF_PIXELS_X               = 25
-NUMBER_OF_PIXELS_Y               = 100
+NUMBER_OF_PIXELS_X               = 7
+NUMBER_OF_PIXELS_Y               = 67
 IGNORE_FAULTY_PARTICLES          = False
 
 # Material parameters:
@@ -53,7 +53,7 @@ GRAY_APPROXIMATION_MFP           = None
 
 # System dimensions [m]:
 THICKNESS                        = 150e-9
-WIDTH                            = 500e-9
+WIDTH                            = 200e-9
 LENGTH                           = 2000e-9
 IS_TWO_DIMENSIONAL_MATERIAL      = False
 INCLUDE_RIGHT_SIDEWALL           = True

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/main_tracing.py

@@ -4,6 +4,7 @@ import os
 import sys
 import time
 import shutil
+import signal
 import multiprocessing
 import traceback
 import logging
@@ -126,6 +127,7 @@ class ParticleSimulator:
 
 
 def worker_process(worker_id, particle_type: ParticleType,total_particles, shared_list, output_trajectories_of, finished_workers):
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
     try:
         # Create a particle simulator and run the simulation:
         simulator = ParticleSimulator(worker_id, particle_type, total_particles, shared_list, output_trajectories_of)
@@ -146,13 +148,17 @@ def worker_process(worker_id, particle_type: ParticleType,total_particles, share
 
 def display_workers_finished(finished_workers):
     """ Print out the number of active workers"""
-    while True:
-        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()
-        if finished_workers.value == cf.num_workers: break
-        time.sleep(0.3)
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    try:
+        while True:
+            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()
+            if finished_workers.value == cf.num_workers: break
+            time.sleep(0.3)
+    except Exception:
+        pass
 
 
 def main(input_file, particle_type):
@@ -196,8 +202,13 @@ def main(input_file, particle_type):
 
     # Wait for all processes to finish:
     # Note that join is not called on worker_count_process because we do not want to wait for it to finish
-    for process in processes:
-        process.join()
+    try:
+        for process in processes:
+            process.join()
+    except KeyboardInterrupt:
+        for process in processes:
+            process.terminate()
+        raise
 
     # Wait for the worker count to finish but continue after 3 seconds:
     worker_count_process.join(timeout=3)
@@ -288,7 +299,7 @@ def main(input_file, particle_type):
     # Output general information:
     output_general_information(start_time)
     output_scattering_information(scatter_stats)
-    output_parameter_warnings()
+    output_parameter_warnings(particle_type)
 
     sys.stdout.write(f'\rSee the results in {Fore.GREEN}Results/{cf.output_folder_name}{Style.RESET_ALL}\n')
     sys.stdout.write(f"\r{Fore.BLUE}Thank you for using FreePATHS{Style.RESET_ALL}\n\n")

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/maps.py

@@ -208,9 +208,10 @@ class ThermalMaps(Maps):
             slope, _ = np.polyfit(coordinates_y, self.temperature_profile_y[:, timeframe_number], 1)
             grad_T = -slope
 
-            # Average heat flux:
-            J_effective = np.mean(self.effective_heat_flux_profile_y[:, timeframe_number])
-            J_material = np.mean(self.material_heat_flux_profile_y[:, timeframe_number])
+            # Average heat flux (skip first pixel — it has a spurious spike due to
+            # rethermalization being applied before map recording in the time-step loop):
+            J_effective = np.mean(self.effective_heat_flux_profile_y[1:, timeframe_number])
+            J_material = np.mean(self.material_heat_flux_profile_y[1:, timeframe_number])
 
             # By definition, J = -K * grad(T), so:
             if grad_T != 0:

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/output_info.py

@@ -39,13 +39,18 @@ def output_scattering_information(scatter_stats):
     """Calculate and output general statistics on scattering events"""
 
     # Calculate the percentage of different scattering events:
-    total = np.sum(scatter_stats.total)
     total_wall = np.sum(scatter_stats.wall_diffuse) + np.sum(scatter_stats.wall_specular)
     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 counts ALL interface events (both reflection and transmission),
+    # because scattering_types.interfaces is set for both. total_transmission is
+    # a subset of total_interf, so must NOT be added separately to avoid double-counting.
     total_interf = np.sum(scatter_stats.interfaces_diffuse) + np.sum(scatter_stats.interfaces_specular)
     total_transmission = np.sum(scatter_stats.interfaces_transmission_specular) + np.sum(scatter_stats.interfaces_transmission_diffuse)
+    total_retherm = np.sum(scatter_stats.hot_side)
+    total_internal = np.sum(scatter_stats.internal)
+    total = total_wall + total_topbot + total_hole + total_pill + total_interf + total_retherm + total_internal
 
     sc_on_walls = 100*(np.sum(scatter_stats.wall_diffuse) +
                          np.sum(scatter_stats.wall_specular)) / total
@@ -62,8 +67,8 @@ def output_scattering_information(scatter_stats):
         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
+    retherm = 100 * total_retherm / total
+    internal = 100 * total_internal / total
 
     info = [
             f'\n{sc_on_walls:.2f}% - scattering on side walls ',
@@ -100,45 +105,54 @@ def output_scattering_information(scatter_stats):
                     )
 
     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
+        sc_on_interf = 100 * total_interf / 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
+        trans_on_interf = 100 * total_transmission / total_interf
+        refl_on_interf  = 100 * (total_interf - total_transmission) / 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)']
-                    )
-
-        trans_on_interf = 100 * (np.sum(scatter_stats.interfaces_transmission_diffuse) +
-                                np.sum(scatter_stats.interfaces_transmission_specular)) / total_interf
-        trans_on_interf_diff = 100*np.sum(scatter_stats.interfaces_transmission_diffuse)/ total_transmission
-        trans_on_interf_spec = 100*np.sum(scatter_stats.interfaces_transmission_specular)/ total_transmission
-
-
-        info.extend([
-                    f'\n{trans_on_interf:.2f}% - transmission through interfaces ',
-                    f'({trans_on_interf_diff:.2f}% - diffuse, ',
-                    f'{trans_on_interf_spec:.2f}% - specular)'
+                    f'{sc_on_interf_spec:.2f}% - specular), ',
+                    f'of which {trans_on_interf:.2f}% - transmission, ',
+                    f'{refl_on_interf:.2f}% - reflection',
                     ])
 
     # Write the file:
     with open("Information.txt", "a", encoding="utf-8") as file:
         file.writelines(info)
 
+    # Warn if multiple scattering events co-occur in a single timestep:
+    total_timesteps_with_scattering = np.sum(scatter_stats.total)
+    if total_timesteps_with_scattering > 0:
+        multi_event_percentage = 100 * (total - total_timesteps_with_scattering) / total_timesteps_with_scattering
+        if multi_event_percentage > 5:
+            logging.warning(f"In {multi_event_percentage:.1f}% of scattering timesteps, more than one scattering "
+                            f"mechanism fired simultaneously. Consider reducing TIMESTEP.")
 
-def output_parameter_warnings():
+
+def output_parameter_warnings(particle_type):
     """Check if parameters used for this simulation made sense considering the simulation results"""
 
-    # Check if some particles had longer travel times than stabilization period:
+    from freepaths.particle_types import ParticleType
+
+    # These checks are only relevant for phonon simulations:
+    if particle_type is not ParticleType.ELECTRON:
+        travel_times = np.loadtxt("Data/All travel times.csv", encoding='utf-8')
+
+        total_time = cf.timestep * cf.number_of_timesteps
+        time_of_stabilization = cf.number_of_stabilization_timeframes * total_time / cf.number_of_timeframes
+        long_travel_times = travel_times[travel_times > time_of_stabilization]
+        percentage = (len(long_travel_times) / len(travel_times)) * 100
+        if percentage > 10:
+            logging.warning(f"Travel time of {percentage}% of particles was longer than the stabilization period.\n" +
+                              "Increase stabilization period as the thermal conductivity might be incorrect.")
+
+    # Check how many particles reached the cold side during simulation:
     travel_times = np.loadtxt("Data/All travel times.csv", encoding='utf-8')
-    total_time = cf.timestep * cf.number_of_timesteps
-    time_of_stabilization = cf.number_of_stabilization_timeframes * total_time / cf. number_of_timeframes
-    long_travel_times = travel_times[travel_times > time_of_stabilization]
-    percentage = (len(long_travel_times) / len(travel_times)) * 100
-    if percentage > 10:
-        logging.warning(f"Travel time of {percentage}% of particles was longer than the stabilization period.\n" +
-                          "Increase stabilization period as the thermal conductivity might be incorrect.")
+    percentage = int(100 * np.count_nonzero(travel_times) / cf.number_of_particles)
+    if percentage < 95:
+        logging.warning(f"Only {percentage}% of particles reached the cold side. Increase the number of timesteps.")
 
     # Check if pixel size is too small:
     speeds = np.loadtxt("Data/All group velocities.csv", encoding='utf-8')
@@ -146,8 +160,3 @@ def output_parameter_warnings():
         logging.warning("Pixels in y direction are smaller than length of one step")
     if max(speeds) * cf.timestep > cf.width / cf.number_of_pixels_x:
         logging.warning("Pixels in x direction are smaller than length of one step")
-
-    # Check how many particles reached the cold side during simulation:
-    percentage = int(100 * np.count_nonzero(travel_times) / cf.number_of_particles)
-    if percentage < 95:
-        logging.warning(f"Only {percentage}% of particles reached the cold side. Increase the number of timesteps.")

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths/output_plots.py

@@ -271,19 +271,6 @@ def plot_interfaces_angles_distribution():
     np.savetxt('Data/Distribution of interfaces angles.csv', angle_distributions, fmt='%1.3e', delimiter=",")
 
 
-import subprocess
-import os
-
-def open_pdf_with_mupdf(pdf_path):
-    try:
-        # path of mu pdf
-        mupdf_path = r"C:\Users\victo\Downloads\mupdf-1.26.2-windows\mupdf-1.26.2-windows\mupdf-gl.exe"
-
-        # Lancer mupdf avec ton fichier
-        subprocess.Popen([mupdf_path, os.path.abspath(pdf_path)])
-    except Exception as e:
-        print(f"[ERROR] Impossible d'ouvrir le PDF avec MuPDF : {e}")
-
 def plot_transmission_vs_angle():
     try:
         angles = np.loadtxt("Data/All interfaces angles.csv", dtype='float', encoding='utf-8')
@@ -808,8 +795,13 @@ def plot_temperature_profile():
     """Plot profile of temperature for each time segment"""
     fig, ax = plt.subplots()
     data = np.genfromtxt("Data/Temperature profiles y.csv", unpack=True, delimiter=',', skip_header=1, encoding='utf-8')
-    for timeframe_num in range(len(data) - 1):
-        ax.plot(data[0][1:], data[timeframe_num + 1][1:], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    coords = data[0]
+    n_timeframes = len(data) - 1
+    for timeframe_num in range(n_timeframes):
+        ax.plot(coords[1:], data[timeframe_num + 1][1:], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    # Linear fit of the last timeframe (same algorithm as thermal conductivity calculation)
+    slope, intercept = np.polyfit(coords, data[n_timeframes], 1)
+    ax.plot(coords[1:], slope * coords[1:] + intercept, '--', color='gray', linewidth=1, label='Linear fit (last frame)')
     ax.set_xlabel('Y (μm)')
     ax.set_ylabel('Temperature (K)')
     ax.legend()
@@ -819,11 +811,16 @@ def plot_temperature_profile():
 def plot_heat_flux_profile():
     """Plot profile of heat flux for each time segment"""
 
+    data = np.genfromtxt("Data/Heat flux profiles y.csv", unpack=True, delimiter=',', skip_header=1, encoding='utf-8')
+    n_timeframes = (len(data) - 1) // 2
+
     # Effective heat flux:
     fig, ax = plt.subplots()
-    data = np.genfromtxt("Data/Heat flux profiles y.csv", unpack=True, delimiter=',', skip_header=1, encoding='utf-8')
-    for timeframe_num in range((len(data) - 1) // 2):
-        ax.plot(data[0], data[timeframe_num + 1], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    for timeframe_num in range(n_timeframes):
+        ax.plot(data[0][1:], data[timeframe_num + 1][1:], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    # Mean of the last timeframe, skipping first pixel (same as thermal conductivity calculation)
+    mean_flux = np.mean(data[n_timeframes][1:])
+    ax.axhline(mean_flux, color='gray', linestyle='--', linewidth=1, label='Mean (last frame)')
     ax.set_xlabel('Y (μm)')
     ax.set_ylabel('Heat flux (W/m²)')
     ax.legend()
@@ -832,8 +829,10 @@ def plot_heat_flux_profile():
 
     # Material heat flux:
     fig, ax = plt.subplots()
-    for timeframe_num in range((len(data) - 1) // 2):
-        ax.plot(data[0], data[2*timeframe_num + 1], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    for timeframe_num in range(n_timeframes):
+        ax.plot(data[0][1:], data[2*timeframe_num + 1][1:], linewidth=1, label=f'Time frame {timeframe_num+1}')
+    mean_flux_mat = np.mean(data[2*n_timeframes - 1][1:])
+    ax.axhline(mean_flux_mat, color='gray', linestyle='--', linewidth=1, label='Mean (last frame)')
     ax.set_xlabel('Y (μm)')
     ax.set_ylabel('Heat flux (W/m²)')
     ax.legend()
@@ -872,7 +871,7 @@ def plot_heat_flux_map(file, label, units="a.u."):
     """Plot heat flux map as color map"""
     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)
+    heat_flux_map = np.abs(np.flipud(heat_flux_map))
     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,
@@ -970,7 +969,8 @@ def plot_scattering_statistics():
         if scattering_type == 6: # Skip hot side scattering
             continue
         # Calculate and plot scattering events per second:
-        scattering_rate = [events / time for events, time in zip(scattering_data[scattering_type, :], time_spent)]
+        scattering_rate = np.divide(scattering_data[scattering_type, :], time_spent,
+                                    out=np.zeros_like(time_spent), where=time_spent != 0)
         all_scattering_rates.append(scattering_rate)
         ax.plot(segments, scattering_rate,  '-o', markersize=2)
 
@@ -995,6 +995,15 @@ def plot_scattering_statistics():
     data = np.vstack((segments, all_scattering_rates)).T
     np.savetxt(filename, data, fmt='%1.2e', delimiter=",", header=header)
 
+    # Save average scattering rates (one value per type, averaged over all segments):
+    avg_header = ("Sidewalls diffuse [1/ns], Sidewalls specular [1/ns], Top & bottom diffuse [1/ns], "
+                  "Top & bottom specular [1/ns], Holes diffuse [1/ns], Holes specular [1/ns], "
+                  "Internal [1/ns], Pillars diffuse [1/ns], Pillars specular [1/ns], "
+                  "Interfaces diffuse [1/ns], Interfaces specular [1/ns], "
+                  "Interfaces transmission diffuse [1/ns], Interfaces transmission specular [1/ns]")
+    avg_data = np.array([np.mean(rate) for rate in all_scattering_rates])
+    np.savetxt("Data/Scattering rates averaged.csv", avg_data.reshape(1, -1), fmt='%1.2e', delimiter=",", header=avg_header)
+
 def plot_scattering_rate_vs_energy():
     fig, ax = plt.subplots()
     energies, scattering_rate = np.genfromtxt("Data/Scattering rate vs energy.csv", unpack=True, delimiter=',', usecols=(0,1), skip_header=1)
@@ -1099,11 +1108,8 @@ def plot_data(particle_type: ParticleType, cf, mfp_sampling=False):
         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_energy_distribution,
         plot_travel_time_vs_energy,
         plot_transport_function,
@@ -1134,6 +1140,10 @@ def plot_data(particle_type: ParticleType, cf, mfp_sampling=False):
     else:
         function_list = electron_function_list
 
+    # These plots require data files that are not saved in low memory mode:
+    if cf.low_memory_usage:
+        function_list = [f for f in function_list if f not in (plot_trajectories, plot_free_path_distribution)]
+
     # Run main functions and handle exceptions:
     for func in function_list:
         try:

{freepaths-2.2.4 → freepaths-2.3.1}/freepaths.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.2.4
+Version: 2.3.1
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
@@ -54,9 +54,13 @@ FreePATHS is a command line application, so it runs inside Linux, MacOS, or Wind
 
 There are two modes of using the program. Main mode traces a large number of phonons through a structure and collects statistics about their paths. The MFP sampling mode measures phonon mean free paths using a small number of phonons and calculates the thermal conductivity by integrating phonon dispersion. 
 
-### Demo
+### Getting started
 
-If you simply run `freepaths` without specifying an input file, the program will run a demo simulation.
+If you run `freepaths` without any arguments, the program will print a usage summary. To run a demo simulation with default parameters, use the `--demo` flag:
+
+`freepaths --demo`
+
+Example input files are available in the [examples](https://github.com/anufrievroman/freepaths/tree/master/examples) folder.
 
 ### Main mode
 

freepaths-2.2.4/freepaths/__main__.py

@@ -1,42 +0,0 @@
-"""FreePATHS - Free Phonon and THermal Simulator"""
-
-import argparse
-import colorama
-from colorama import Fore, Style
-
-from freepaths.particle_types import ParticleType
-
-__version__ = "2.2.4"
-
-colorama.init()
-
-# Parse user arguments:
-parser = argparse.ArgumentParser(
-                prog = 'FreePATHS',
-                description = 'Phonon Monte Carlo simulator',
-                epilog = 'For more information, examples, and tutorials, visit: https://anufrievroman.gitbook.io/freepaths'
-                )
-parser.add_argument('input_file', nargs='?', default=None, help='The input file')
-parser.add_argument("-s", "--sampling", help="Run in phonon MFP sampling mode", action="store_true")
-parser.add_argument("-e", "--electron", help="Run simulation for electrons", action="store_true")
-args = parser.parse_args()
-
-
-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, ParticleType.PHONON)
-
-    elif args.electron:
-        import freepaths.main_tracing
-        freepaths.main_tracing.main(args.input_file, ParticleType.ELECTRON)
-
-    else:
-        import freepaths.main_tracing
-        freepaths.main_tracing.main(args.input_file, ParticleType.PHONON)
-
-
-if __name__ == "__main__":
-    run()