freepaths 2.3.3__tar.gz → 2.3.4__tar.gz

{freepaths-2.3.3 → freepaths-2.3.4}/PKG-INFO

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

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/__main__.py

@@ -5,9 +5,9 @@ import argparse
 import colorama
 from colorama import Fore, Style
 
-from freepaths.particle_types import ParticleType
+from freepaths.options import SimulationMode
 
-__version__ = "2.3.3"
+__version__ = "2.3.4"
 
 colorama.init()
 
@@ -45,15 +45,15 @@ def run():
     try:
         if args.sampling:
             import freepaths.main_mfp_sampling
-            freepaths.main_mfp_sampling.main(args.input_file, ParticleType.PHONON)
+            freepaths.main_mfp_sampling.main(args.input_file, SimulationMode.PHONON_MFP_SAMPLING)
 
         elif args.electron:
             import freepaths.main_tracing
-            freepaths.main_tracing.main(args.input_file, ParticleType.ELECTRON)
+            freepaths.main_tracing.main(args.input_file, SimulationMode.ELECTRON)
 
         else:
             import freepaths.main_tracing
-            freepaths.main_tracing.main(args.input_file, ParticleType.PHONON)
+            freepaths.main_tracing.main(args.input_file, SimulationMode.PHONON_TRACING)
 
     except KeyboardInterrupt:
         print(f"\n{Fore.RED}Simulation interrupted by user.{Style.RESET_ALL}")

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/config.py

@@ -3,6 +3,7 @@ Module that reads the user input file, provides default values,
 checks the validity of the parameters and converts the variables into enums
 """
 
+import os
 import sys
 import argparse
 import logging
@@ -32,8 +33,11 @@ args = parser.parse_args()
 
 # If a file is provided, overwrite the default values:
 if args.input_file:
+    input_path = args.input_file
+    if not os.path.isfile(input_path) and not input_path.endswith('.py') and os.path.isfile(input_path + '.py'):
+        input_path = input_path + '.py'
     try:
-        exec(open(args.input_file, encoding='utf-8').read(), globals())
+        exec(open(input_path, 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()

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/data.py

@@ -66,43 +66,53 @@ class GeneralData(Data):
         self.travel_times = []
         self.mean_free_paths = []
         self.thermal_conductivity = []
-    def save_particle_data(self, pt):
+    def save_particle_data(self, pt, mode=None):
         """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):
+        from freepaths.options import SimulationMode
+        if mode is SimulationMode.ELECTRON:
+            self.initial_energies.append(pt.energy)
+        else:
+            self.frequencies.append(pt.f)
+            self.group_velocities.append(pt.speed)
+
+    def save_flight_data(self, flight, mode=None):
         """Add information about the particle flight to the dataset"""
+        from freepaths.options import SimulationMode
         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.hole_diff_scattering_angles.extend(flight.hole_diff_scattering_angles)
-        self.hole_spec_scattering_angles.extend(flight.hole_spec_scattering_angles)
+        if mode is SimulationMode.PHONON_TRACING:
+            self.initial_angles.append(flight.initial_theta)
+            self.exit_angles.append(flight.exit_theta)
+            self.hole_diff_scattering_angles.extend(flight.hole_diff_scattering_angles)
+            self.hole_spec_scattering_angles.extend(flight.hole_spec_scattering_angles)
         self.travel_times.append(flight.travel_time)
         self.mean_free_paths.append(flight.mean_free_path)
-        self.thermal_conductivity.append(flight.thermal_conductivity)
-
+        if mode is SimulationMode.PHONON_MFP_SAMPLING:
+            self.thermal_conductivity.append(flight.thermal_conductivity)
 
-    def write_into_files(self):
+    def write_into_files(self, mode=None):
         import os
+        from freepaths.options import SimulationMode
         if not os.path.exists("Data"):
             os.makedirs("Data")
         """Write all the data into files"""
         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')
-        if cf.holes:
-            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')
+        if mode is SimulationMode.ELECTRON:
+            np.savetxt("Data/All initial energies.csv", self.initial_energies, fmt='%2.4e', header="Energy [J]", encoding='utf-8')
+        else:
+            np.savetxt("Data/All initial frequencies.csv", self.frequencies, fmt='%2.4e', header="f [Hz]", encoding='utf-8')
+            np.savetxt("Data/All group velocities.csv", self.group_velocities, fmt='%.4f', header="Vg [m//s]", encoding='utf-8')
+        if mode is SimulationMode.PHONON_TRACING:
+            np.savetxt("Data/All exit angles.csv", self.exit_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')
+            if cf.holes:
+                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 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')
+        if mode is SimulationMode.PHONON_MFP_SAMPLING:
+            np.savetxt("Data/All thermal conductivities.csv", self.thermal_conductivity, fmt='%2.4e', header="K [W/mK]", 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 {

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/electron.py

@@ -4,7 +4,7 @@ from random import choice, random
 from scipy.constants import h, electron_volt
 from freepaths.config import cf
 from freepaths.particle import Particle
-from freepaths.particle_types import ParticleType
+from freepaths.options import ParticleType
 
 import numpy as np
 

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/main_mfp_sampling.py

@@ -19,26 +19,49 @@ from freepaths.config import cf
 from freepaths.run_particle import run_particle
 from freepaths.phonon import Phonon
 from freepaths.flight import Flight
-from freepaths.particle_types import ParticleType
+from freepaths.options import SimulationMode
 from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
 from freepaths.materials import Si, SiC, Graphite, SiGe
 from freepaths.maps import ScatteringMap
-from freepaths.progress import Progress
 from freepaths.output_info import output_general_information, output_scattering_information, output_parameter_warnings
+from freepaths.materials import get_media_class
 from freepaths.output_plots import plot_data
 
 
-def _branch_worker(branch_number, shared_list):
+def display_all_progress(shared_progress, finished_branches, branch_names):
+    """Render a live progress percentage for each branch on its own line."""
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    n = len(branch_names)
+    width = max(len(name) for name in branch_names)
+    try:
+        for name in branch_names:
+            sys.stdout.write(f'  {name.ljust(width)}:   0%\n')
+        sys.stdout.flush()
+        while True:
+            sys.stdout.write(f'\033[{n}A')
+            for i, name in enumerate(branch_names):
+                sys.stdout.write(f'\r  {name.ljust(width)}: {shared_progress[i]:3d}%\n')
+            sys.stdout.flush()
+            if finished_branches.value == n:
+                break
+            time.sleep(0.1)
+    except Exception:
+        pass
+
+
+def _branch_worker(branch_number, shared_list, finished_branches, shared_progress):
     """Entry point for each worker process. Catches exceptions so they are logged
     rather than silently swallowed by the multiprocessing machinery."""
     signal.signal(signal.SIGINT, signal.SIG_IGN)
     try:
-        _run_branch(branch_number, shared_list)
+        _run_branch(branch_number, shared_list, shared_progress)
+        shared_progress[branch_number] = 100
+        finished_branches.value += 1
     except Exception:
         logging.exception("Branch worker %d crashed", branch_number)
 
 
-def _run_branch(branch_number, shared_list):
+def _run_branch(branch_number, shared_list, shared_progress):
     """Run all phonons for one polarization branch and push results to shared_list.
 
     Each call processes NUMBER_OF_PARTICLES phonons sampled uniformly across the
@@ -47,7 +70,7 @@ def _run_branch(branch_number, shared_list):
     flight.thermal_conductivity over all phonons approximates the branch integral
     in Phys. Rev. 132 2461 (1963).
 
-    Branch 0 also drives the shared progress bar; the other two run silently.
+    Branch 2 (TA) drives the shared progress bar; the other two run silently.
     Results are appended to shared_list as a dict of dump_data() payloads so that
     the main process can merge them with the standard read_data() mechanism.
     """
@@ -76,11 +99,13 @@ def _run_branch(branch_number, shared_list):
     scatter_maps = ScatteringMap()
 
     total_thermal_conductivity = 0.0
-    progress = Progress() if branch_number == 0 else None
+    last_pct = -1
 
     for index in range(cf.number_of_particles):
-        if progress:
-            progress.render(index, cf.number_of_particles)
+        pct = 100 * index // cf.number_of_particles
+        if pct > last_pct:
+            shared_progress[branch_number] = pct
+            last_pct = pct
 
         # Mid-point k-vector and integration weight for this phonon:
         k_vector = (material.dispersion[index + 1, 0] + material.dispersion[index, 0]) / 2
@@ -101,8 +126,8 @@ def _run_branch(branch_number, shared_list):
         flight.thermal_conductivity = (1 / (6 * math.pi**2)) * c_p * phonon.speed**2 * mean_relax_time * k_vector**2 * d_k_vector
         total_thermal_conductivity += flight.thermal_conductivity
 
-        general_stats.save_particle_data(phonon)
-        general_stats.save_flight_data(flight)
+        general_stats.save_particle_data(phonon, SimulationMode.PHONON_MFP_SAMPLING)
+        general_stats.save_flight_data(flight, SimulationMode.PHONON_MFP_SAMPLING)
 
         if index < cf.output_trajectories_of_first:
             path_stats.save_particle_path(flight)
@@ -119,24 +144,32 @@ def _run_branch(branch_number, shared_list):
     })
 
 
-def main(input_file, particle_type):
+def main(input_file, mode: SimulationMode):
     """Integrate the phonon dispersion over all three branches in parallel to get
     the bulk thermal conductivity via the MFP-sampling method."""
 
     print(f'Mean free path sampling of {Fore.GREEN}{cf.output_folder_name}{Style.RESET_ALL}')
     start_time = time.time()
 
-    # Spawn one worker process per polarization branch (LA + 2×TA).
-    # All three run concurrently; branch 0 reports progress to stdout:
+    branch_names = get_media_class(cf.media).branch_names
+    n_branches = len(branch_names)
+
+    # Spawn one worker process per polarization branch, all running concurrently:
     manager = multiprocessing.Manager()
     shared_list = manager.list()
+    finished_branches = manager.Value('i', 0)
+    shared_progress = manager.list([0] * n_branches)
 
     processes = [
-        multiprocessing.Process(target=_branch_worker, args=(branch_number, shared_list))
-        for branch_number in range(3)
+        multiprocessing.Process(target=_branch_worker, args=(branch_number, shared_list, finished_branches, shared_progress))
+        for branch_number in range(n_branches - 1, -1, -1)
     ]
     for process in processes:
         process.start()
+
+    display_process = multiprocessing.Process(target=display_all_progress, args=(shared_progress, finished_branches, branch_names))
+    display_process.start()
+
     try:
         for process in processes:
             process.join()
@@ -145,6 +178,9 @@ def main(input_file, particle_type):
             process.terminate()
         raise
 
+    display_process.join(timeout=3)
+    display_process.terminate()
+
     # Merge per-branch results into single data structures:
     scatter_stats = ScatteringData()
     general_stats = GeneralData()
@@ -172,7 +208,7 @@ def main(input_file, particle_type):
     os.chdir("Results/" + cf.output_folder_name)
 
     # Save data and generate plots:
-    general_stats.write_into_files()
+    general_stats.write_into_files(mode)
     scatter_stats.write_into_files()
     segment_stats.write_into_files()
     if cf.output_scattering_map:
@@ -185,11 +221,11 @@ def main(input_file, particle_type):
     np.savetxt("Data/Thermal conductivity from MFP.csv", np.array([total_thermal_conductivity]), fmt='%2.4e', header="K [W/mK]", encoding='utf-8')
 
     sys.stdout.write("\rAnalyzing the data...")
-    plot_data(particle_type, cf, mfp_sampling=True)
+    plot_data(mode, cf)
 
     output_general_information(start_time)
     output_scattering_information(scatter_stats)
-    output_parameter_warnings(ParticleType.PHONON)
+    output_parameter_warnings(mode)
     sys.stdout.write(f'\rSee the results in {Fore.GREEN}Results/{cf.output_folder_name}{Style.RESET_ALL}\n')
     sys.stdout.write(f"\rThermal conductivity = {Fore.GREEN}{total_thermal_conductivity:.5f}{Style.RESET_ALL} W/m·K\n")
     sys.stdout.write(f"\r{Fore.BLUE}Thank you for using FreePATHS{Style.RESET_ALL}\n\n")

{freepaths-2.3.3 → freepaths-2.3.4}/freepaths/main_tracing.py

@@ -8,6 +8,7 @@ import signal
 import multiprocessing
 import traceback
 import logging
+import numpy as np
 from colorama import Fore, Style
 
 # Modules:
@@ -16,13 +17,13 @@ from freepaths.run_particle import run_particle
 from freepaths.electron import Electron
 from freepaths.phonon import Phonon
 from freepaths.flight import Flight
-from freepaths.particle_types import ParticleType
+from freepaths.options import SimulationMode
 from freepaths.data import ScatteringData, GeneralData, SegmentData, PathData, TriangleScatteringData
 from freepaths.post_computations import ElectronPostComputation
 from freepaths.progress import Progress
 from freepaths.materials import Si, SiC, Graphite, SiGe
 from freepaths.maps import ScatteringMap, ThermalMaps
-from freepaths.output_info import output_general_information, output_scattering_information, output_parameter_warnings
+from freepaths.output_info import output_general_information, output_scattering_information, output_parameter_warnings, output_electron_information
 from freepaths.animation import create_animation
 from freepaths.output_plots import plot_data
 from freepaths.scattering import surface_scattering
@@ -34,7 +35,7 @@ class ParticleSimulator:
     It is meant to be used as a worker for multiprocessing
     """
 
-    def __init__(self, worker_id, particle_type: ParticleType, total_particles, shared_list, output_trajectories_of):
+    def __init__(self, worker_id, mode: SimulationMode, total_particles, shared_list, output_trajectories_of):
 
         # Initialize the material:
         if cf.media == "Si":
@@ -52,7 +53,7 @@ class ParticleSimulator:
         # Save some general information about the process:
         self.worker_id = worker_id
         self.total_particles = total_particles
-        self.particle_type = particle_type
+        self.mode = mode
         self.result_queue = shared_list
         self.creation_time = time.time()
         self.output_trajectories_of = output_trajectories_of
@@ -65,7 +66,7 @@ class ParticleSimulator:
         self.path_stats = PathData()
         self.places_stats = TriangleScatteringData()
         self.scatter_maps = ScatteringMap()
-        self.thermal_maps = ThermalMaps()
+        self.thermal_maps = ThermalMaps() if mode is SimulationMode.PHONON_TRACING else None
 
         self.total_thermal_conductivity = 0.0
         self.interfaces_transmission_specular = 0
@@ -74,10 +75,10 @@ class ParticleSimulator:
 
     def simulate_particle(self, index):
         # Initiate a particle and its flight:
-        if self.particle_type is ParticleType.PHONON:
-            particle = Phonon(self.material)
-        else:
+        if self.mode is SimulationMode.ELECTRON:
             particle = Electron(self.material)
+        else:
+            particle = Phonon(self.material)
         flight = Flight(particle)
         particle.flight = flight
 
@@ -85,8 +86,8 @@ class ParticleSimulator:
         run_particle(particle, flight, self.scatter_stats, self.places_stats, self.segment_stats, self.thermal_maps, self.scatter_maps, self.material)
 
         # Record the properties returned for this particle:
-        self.general_stats.save_particle_data(particle) # FIXME: change method's name
-        self.general_stats.save_flight_data(flight)
+        self.general_stats.save_particle_data(particle, self.mode)
+        self.general_stats.save_flight_data(flight, self.mode)
 
         # Record trajectories of the first N particles:
         if index < self.output_trajectories_of:
@@ -118,7 +119,7 @@ class ParticleSimulator:
             'segment_stats': self.segment_stats.dump_data(),
             'path_stats': self.path_stats.dump_data(),
             'scatter_maps': self.scatter_maps.dump_data(),
-            'thermal_maps': self.thermal_maps.dump_data(),
+            'thermal_maps': self.thermal_maps.dump_data() if self.thermal_maps is not None else {},
             'execution_time': time.time() - self.creation_time,
         }
 
@@ -126,11 +127,11 @@ class ParticleSimulator:
         self.result_queue.append(collected_data)
 
 
-def worker_process(worker_id, particle_type: ParticleType,total_particles, shared_list, output_trajectories_of, finished_workers):
+def worker_process(worker_id, mode: SimulationMode, 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)
+        simulator = ParticleSimulator(worker_id, mode, total_particles, shared_list, output_trajectories_of)
         simulator.simulate_particles(render_progress=1 if worker_id == 0 else 0)
 
         # Declare that the calculation is finished:
@@ -161,7 +162,7 @@ def display_workers_finished(finished_workers):
         pass
 
 
-def main(input_file, particle_type):
+def main(input_file, mode: SimulationMode):
     """
     This is the main function.
     It should be used to simulate electron paths or phonon paths at low temperatures.
@@ -192,7 +193,7 @@ def main(input_file, particle_type):
     for i in range(cf.num_workers):
         worker_particles = workload_per_worker + (1 if i < remaining_particles else 0)
         output_trajectory_of = output_trajectories_per_worker + (1 if i < remaining_output_trajectories else 0)
-        process = multiprocessing.Process(target=worker_process, args=(i, particle_type, worker_particles, shared_list, output_trajectory_of, finished_workers))
+        process = multiprocessing.Process(target=worker_process, args=(i, mode, worker_particles, shared_list, output_trajectory_of, finished_workers))
         processes.append(process)
         process.start()
 
@@ -222,7 +223,7 @@ def main(input_file, particle_type):
     segment_stats = SegmentData()
     path_stats = PathData()
     scatter_maps = ScatteringMap()
-    thermal_maps = ThermalMaps()
+    thermal_maps = ThermalMaps() if mode is SimulationMode.PHONON_TRACING else None
 
     # Collect the results:
     sys.stdout.write('\nCollecting data from workers...\r')
@@ -243,7 +244,8 @@ def main(input_file, particle_type):
         segment_stats.read_data(collected_data['segment_stats'])
         path_stats.read_data(collected_data['path_stats'])
         scatter_maps.read_data(collected_data['scatter_maps'])
-        thermal_maps.read_data(collected_data['thermal_maps'])
+        if thermal_maps is not None:
+            thermal_maps.read_data(collected_data['thermal_maps'])
         execution_time_list.append(collected_data['execution_time'])
 
     # Give some info about the variability in the worker calculation time:
@@ -251,17 +253,13 @@ def main(input_file, particle_type):
         sys.stdout.write(f'Shortest process execution time: {round(min(execution_time_list))}s\n')
         sys.stdout.write(f'Longest process execution time: {round(max(execution_time_list))}s\n')
 
-    # Check if the total number of returned particles from the workers corresponds with the number of particles to be simulated:
-    if len(general_stats.initial_angles) != cf.number_of_particles:
-        sys.stdout.write(f'WARNING: {cf.number_of_particles} were meant to be simulated but only {len(general_stats.initial_angles)} particles were collected from the workers\n')
-
     # Run thermal calculations:
-    thermal_maps.calculate_thermal_conductivity()
-    thermal_maps.calculate_weighted_flux()
-    thermal_maps.calculate_heat_flux_modulus()
+    if thermal_maps is not None:
+        thermal_maps.calculate_thermal_conductivity()
+        thermal_maps.calculate_heat_flux_modulus()
 
     # Run calculations on electrons if needed:
-    if particle_type is ParticleType.ELECTRON:
+    if mode is SimulationMode.ELECTRON:
 
         electron_computations = ElectronPostComputation(general_stats)
         electron_computations.compute()
@@ -276,18 +274,36 @@ def main(input_file, particle_type):
         shutil.copy(input_file, "Results/" + cf.output_folder_name)
     os.chdir("Results/" + cf.output_folder_name)
 
+    # Try to load pre-computed phonon thermal conductivity to enable ZT calculation:
+    if mode is SimulationMode.ELECTRON:
+        kappa_ph = None
+        if os.path.isfile("Data/Thermal conductivity from MFP.csv"):
+            try:
+                kappa_ph = float(np.genfromtxt("Data/Thermal conductivity from MFP.csv", skip_header=1))
+            except Exception:
+                pass
+        elif os.path.isfile("Data/Average thermal conductivity.csv"):
+            try:
+                data = np.genfromtxt("Data/Average thermal conductivity.csv", delimiter=',', skip_header=1)
+                kappa_ph = float(np.atleast_1d(data)[1])  # column 1 = av_mat_tc
+            except Exception:
+                pass
+        if kappa_ph is not None:
+            electron_computations.compute_zt(kappa_ph)
+
     # Save data into files:
     sys.stdout.write("\rSaving raw data...")
-    general_stats.write_into_files()
+    general_stats.write_into_files(mode)
     scatter_stats.write_into_files()
     if cf.holes:
         places_stats.write_into_files()
     segment_stats.write_into_files()
-    thermal_maps.write_into_files()
+    if thermal_maps is not None:
+        thermal_maps.write_into_files(mode)
     if cf.output_scattering_map:
         scatter_maps.write_into_files()
     path_stats.write_into_files()
-    if particle_type is ParticleType.ELECTRON:
+    if mode is SimulationMode.ELECTRON:
         electron_computations.write_into_file()
 
     # Generate animation of particle paths:
@@ -296,12 +312,14 @@ def main(input_file, particle_type):
 
     # Analyze and plot the data:
     sys.stdout.write("\rAnalyzing the data...")
-    plot_data(particle_type, cf)
+    plot_data(mode, cf)
 
     # Output general information:
     output_general_information(start_time)
     output_scattering_information(scatter_stats)
-    output_parameter_warnings(particle_type)
+    if mode is SimulationMode.ELECTRON:
+        output_electron_information(electron_computations)
+    output_parameter_warnings(mode)
 
     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")