freepaths 2.4.1__tar.gz → 2.4.3__tar.gz

{freepaths-2.4.1 → freepaths-2.4.3}/PKG-INFO

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

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths/__main__.py

@@ -7,7 +7,7 @@ from colorama import Fore, Style
 
 from freepaths.options import SimulationMode
 
-__version__ = "2.4.1"
+__version__ = "2.4.3"
 
 colorama.init()
 

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths/data.py

@@ -70,6 +70,14 @@ class GeneralData(Data):
         self.travel_times = []
         self.mean_free_paths = []
         self.thermal_conductivity = []
+        # Per-phonon internal and boundary scattering rates (MFP-sampling mode only),
+        # the two channels of the total rate v/MFP resolved as a function of frequency:
+        self.internal_scattering_rates = []
+        self.boundary_scattering_rates = []
+        # Per-phonon dispersion branch index (0=LA, 1=TA1, 2=TA2, ...). In MFP-sampling
+        # mode each phonon keeps its launch branch (no rethermalization), so this lets the
+        # scattering-rate spectra be resolved per branch. Row-aligned with the arrays above.
+        self.branches = []
     def save_particle_data(self, pt, mode=None):
         """Add information about the particle to the dataset"""
         from freepaths.options import SimulationMode
@@ -78,6 +86,7 @@ class GeneralData(Data):
         else:
             self.final_frequencies.append(pt.f)
             self.group_velocities.append(pt.speed)
+            self.branches.append(pt.branch_number)
 
     def save_flight_data(self, flight, mode=None):
         """Add information about the particle flight to the dataset"""
@@ -95,6 +104,8 @@ class GeneralData(Data):
         self.mean_free_paths.append(flight.mean_free_path)
         if mode is SimulationMode.PHONON_MFP_SAMPLING:
             self.thermal_conductivity.append(flight.thermal_conductivity)
+            self.internal_scattering_rates.append(flight.internal_scattering_rate)
+            self.boundary_scattering_rates.append(flight.boundary_scattering_rate)
 
     def write_into_files(self, mode=None):
         import os
@@ -121,6 +132,9 @@ class GeneralData(Data):
         np.savetxt("Data/All mean free paths.csv", self.mean_free_paths, fmt='%2.4e', header="MFPs [m]", 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')
+            np.savetxt("Data/All internal scattering rates.csv", self.internal_scattering_rates, fmt='%2.4e', header="1/tau_internal [1/s]", encoding='utf-8')
+            np.savetxt("Data/All boundary scattering rates.csv", self.boundary_scattering_rates, fmt='%2.4e', header="1/tau_boundary [1/s]", encoding='utf-8')
+            np.savetxt("Data/All branches.csv", self.branches, fmt='%d', header="Branch index (0=LA, 1=TA1, 2=TA2)", 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 {
@@ -136,6 +150,9 @@ class GeneralData(Data):
             'travel_times': self.travel_times,
             'mean_free_paths': self.mean_free_paths,
             'thermal_conductivity': self.thermal_conductivity,
+            'internal_scattering_rates': self.internal_scattering_rates,
+            'boundary_scattering_rates': self.boundary_scattering_rates,
+            'branches': self.branches,
             'initial_energies': self.initial_energies,
         }
 

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths/flight.py

@@ -45,6 +45,11 @@ class Flight:
         self.free_paths = []
         self._mfp_sum = 0.0
         self._mfp_count = 0
+        # Per-channel counts of the diffuse events that terminate a free-path segment,
+        # used to split the total scattering rate v/MFP into internal (phonon-phonon +
+        # impurity) and boundary (diffuse surface) spectra in the MFP-sampling mode:
+        self._internal_count = 0
+        self._boundary_count = 0
         self.hole_diff_scattering_angles = []
         self.hole_spec_scattering_angles = []
         self.thermal_conductivity = 0.0
@@ -53,6 +58,24 @@ class Flight:
         """Mean value of all free flights"""
         return self._mfp_sum / self._mfp_count if self._mfp_count else 0
 
+    @property
+    def internal_scattering_rate(self):
+        """Per-phonon internal (phonon-phonon + impurity) scattering rate [1/s]:
+        number of internal events divided by the total flight time (mfp_sum / speed).
+        Summed with boundary_scattering_rate this recovers the total rate v/MFP, so the
+        two split the total scattering-rate spectrum into physical channels."""
+        if self._mfp_sum <= 0:
+            return 0.0
+        return self.particle.speed * self._internal_count / self._mfp_sum
+
+    @property
+    def boundary_scattering_rate(self):
+        """Per-phonon boundary (diffuse surface) scattering rate [1/s]: number of
+        diffuse boundary events divided by the total flight time (mfp_sum / speed)."""
+        if self._mfp_sum <= 0:
+            return 0.0
+        return self.particle.speed * self._boundary_count / self._mfp_sum
+
     @property
     def mean_free_path_sem(self):
         """Standard error of the mean free path (MFP sampling mode only). Assumes
@@ -74,6 +97,14 @@ class Flight:
         if not cf.low_memory_usage:
             self.free_paths.append(self.free_path)
 
+    def record_scattering_channel(self, is_internal, is_boundary):
+        """Tally the channel of a diffuse event that ends a free-path segment, so the
+        total scattering rate can later be split into internal and boundary spectra."""
+        if is_internal:
+            self._internal_count += 1
+        if is_boundary:
+            self._boundary_count += 1
+
     def save_hole_diff_scattering_angle(self, angle):
         """Save angle of diffuse scattering from the hole"""
         self.hole_diff_scattering_angles.append(angle)

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths/output_plots.py

@@ -266,37 +266,106 @@ def plot_velocity_distribution():
 
 
 def plot_scattering_rate_vs_frequency():
-    """Plot phonon scattering rate (1/τ = v/MFP) vs frequency with theoretical internal rate"""
+    """Plot phonon scattering rate (1/τ = v/MFP) vs frequency, resolved per dispersion
+    branch (color + marker shape: LA / TA1 / TA2) and per channel (marker fill:
+    filled = Total, open = Boundary, small dot = Internal), with the theoretical
+    internal rate overlaid. MFP-sampling mode."""
+    from matplotlib.lines import Line2D
+
     mfps = np.loadtxt("Data/All mean free paths.csv")
     frequencies = np.loadtxt("Data/All final frequencies.csv")
     speeds = np.loadtxt("Data/All group velocities.csv")
     mask = mfps > 0
     scattering_rates = speeds[mask] / mfps[mask]
+    f_masked = frequencies[mask]
+
+    # Per-channel MC rates and per-phonon branch index written by GeneralData in
+    # MFP-sampling mode (internal + boundary ≈ total). Optional so the plot still
+    # works on older result folders:
+    internal_rates = boundary_rates = branches = None
+    try:
+        internal_rates = np.loadtxt("Data/All internal scattering rates.csv")
+        boundary_rates = np.loadtxt("Data/All boundary scattering rates.csv")
+    except OSError:
+        pass
+    try:
+        branches = np.atleast_1d(np.loadtxt("Data/All branches.csv")).astype(int)
+    except OSError:
+        pass
 
     # Theoretical internal scattering rate from material model:
     material = get_media_class(cf.media)(cf.temp)
-    f_range = np.linspace(frequencies[mask].min(), frequencies[mask].max(), 500)
-    omega_range = 2 * np.pi * f_range
-    tau_internal = np.array([material.phonon_relaxation_time(w) for w in omega_range])
-
+    f_range = np.linspace(f_masked.min(), f_masked.max(), 500)
+    tau_internal = np.array([material.phonon_relaxation_time(w) for w in 2 * np.pi * f_range])
     step_rate_ns = 1e-9 / cf.timestep  # 1/TIMESTEP in ns⁻¹
 
+    branch_names = material.dispersion_branch_names
+    branch_colors = ['royalblue', '#5ec962', 'crimson', 'darkorange']  # one per branch
+    # Channel -> marker shape (+ a slightly different alpha to help separate overlaps):
+    channel_names = ['Total', 'Boundary', 'Internal']
+    channel_markers = ['o', 's', '^']
+    channel_alphas = [0.9, 0.6, 0.5]
+
     fig, ax = plt.subplots()
-    ax.plot(frequencies[mask] * 1e-12, scattering_rates * 1e-9, '.', markersize=2, c='royalblue', label='MC total')
-    ax.plot(f_range * 1e-12, 1e-9 / tau_internal, '--', linewidth=0.8, c='deeppink', label='Internal (theory)')
+    have_channels = internal_rates is not None and boundary_rates is not None
+
+    if branches is not None and have_channels:
+        # Branch-resolved: branch -> color, channel -> marker shape + alpha.
+        br = branches[mask]
+        intr, bnd = internal_rates[mask], boundary_rates[mask]
+        present = [b for b in range(len(branch_names)) if np.any(br == b)]
+        for b in present:
+            sel = br == b
+            color = branch_colors[b % 4]
+            fx = f_masked[sel] * 1e-12
+            channel_data = [scattering_rates[sel], bnd[sel], intr[sel]]
+            for cdata, marker, alpha in zip(channel_data, channel_markers, channel_alphas):
+                ax.scatter(fx, cdata * 1e-9, s=8, marker=marker, color=color,
+                           alpha=alpha, linewidths=0)
+
+        # Two proxy legends: branch (color), channel (marker shape):
+        branch_handles = [Line2D([], [], linestyle='None', marker='o', markersize=4,
+                                 markerfacecolor=branch_colors[b % 4],
+                                 markeredgecolor=branch_colors[b % 4], label=branch_names[b]) for b in present]
+        branch_handles.append(Line2D([], [], color='gray', linestyle='--', label='Internal (Theory)'))
+        channel_handles = [Line2D([], [], linestyle='None', marker=m, markersize=4,
+                                  markerfacecolor='gray', markeredgecolor='gray', label=n)
+                           for m, n in zip(channel_markers, channel_names)]
+        # Two horizontal legends side by side above the axes (branch on the left,
+        # channel on the right), clear of the data:
+        leg1 = ax.legend(handles=branch_handles, loc='lower left', bbox_to_anchor=(0, 1.02),
+                         ncol=len(branch_handles), fontsize=5.5, title='Branch', title_fontsize=6,
+                         columnspacing=0.8, handletextpad=0.3)
+        ax.add_artist(leg1)
+        ax.legend(handles=channel_handles, loc='lower right', bbox_to_anchor=(1, 1.02),
+                  ncol=len(channel_handles), fontsize=5.5, title='Channel', title_fontsize=6,
+                  columnspacing=0.8, handletextpad=0.3)
+
+        # Consolidated CSV in long format, sorted by (branch, frequency):
+        order = np.lexsort((f_masked, br))
+        legend = ", ".join(f"{i}={name}" for i, name in enumerate(branch_names))
+        spectra = np.column_stack((br, f_masked, scattering_rates, intr, bnd))[order]
+        np.savetxt("Data/Distribution of scattering rates.csv", spectra,
+                   fmt=['%d', '%2.4e', '%2.4e', '%2.4e', '%2.4e'], delimiter=',',
+                   header=f"branch ({legend}), f [Hz], Total (MC) [1/s], "
+                          "Internal (MC) [1/s], Boundary (MC) [1/s]", encoding='utf-8')
+    else:
+        # Fallback for older result folders without branch/channel data: total only.
+        ax.plot(f_masked * 1e-12, scattering_rates * 1e-9, '.', markersize=2, c='black', label='Total (MC)')
+        ax.legend(fontsize=7)
+        order = np.argsort(f_masked)
+        np.savetxt("Data/Distribution of scattering rates.csv",
+                   np.column_stack((f_masked, scattering_rates))[order],
+                   fmt='%2.4e', delimiter=',', header="f [Hz], Total (MC) [1/s]", encoding='utf-8')
+
+    ax.plot(f_range * 1e-12, 1e-9 / tau_internal, '--', linewidth=0.8, c='gray')
     ax.set_xlabel('Frequency (THz)')
     ax.set_ylabel(r'Scattering rate (ns$^{-1}$)')
-    ax.legend()
     ax.text(0.98, 0.04, f'Step rate = {step_rate_ns:.1f} ns$^{{-1}}$',
-            transform=ax.transAxes, ha='right', va='bottom',
-            fontsize=7, color='gray')
+            transform=ax.transAxes, ha='right', va='bottom', fontsize=7, color='gray')
     fig.savefig('Distribution of phonon scattering rates.pdf', format='pdf', bbox_inches="tight")
     plt.close(fig)
 
-    mc_data = np.vstack((frequencies[mask] * 1e-12, scattering_rates * 1e-9)).T
-    np.savetxt('Data/Distribution of phonon scattering rates.csv', mc_data, fmt='%1.3e', delimiter=",",
-               header="Frequency (THz),MC total scattering rate (1/ns)")
-
 
 def plot_energy_distribution():
     """Plot distribution of energy"""

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths/run_particle.py

@@ -56,6 +56,7 @@ def run_particle(particle, flight, scatter_stats, places_stats, segment_stats, t
 
         # If diffuse scattering has occurred, reset particle free path:
         if scattering_types.is_diffuse or scattering_types.is_internal:
+            flight.record_scattering_channel(scattering_types.is_internal, scattering_types.is_diffuse)
             flight.save_free_paths()
             flight.restart()
             # An inelastic (anharmonic) internal event rethermalizes the phonon: new

{freepaths-2.4.1 → freepaths-2.4.3}/freepaths.egg-info/PKG-INFO

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