freepaths 2.5.1__tar.gz → 2.6__tar.gz

{freepaths-2.5.1 → freepaths-2.6}/PKG-INFO

@@ -1,23 +1,22 @@
 Metadata-Version: 2.4
 Name: freepaths
-Version: 2.5.1
+Version: 2.6
 Summary: Phonon Monte Carlo simulator
 Home-page: https://github.com/anufrievroman/freepaths
 Author: Roman Anufriev
 Author-email: anufriev.roman@protonmail.com
-License: GPL
+License-Expression: GPL-3.0-only
 Classifier: Development Status :: 4 - Beta
-Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Environment :: Console
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Utilities
 Requires-Python: ~=3.11
 Description-Content-Type: text/markdown
+License-File: license
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: scipy
@@ -28,7 +27,8 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
-Dynamic: license
+Dynamic: license-file
+Dynamic: license-expression
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -94,6 +94,16 @@ Alternatively, you can run FreePATHS in the mean free path sampling mode, which
 The calculated thermal conductivity will be output in the terminal. However, other statistical quantities and plots will still be calculated and output in the `Results` folder.
 
 
+## Testing
+
+The `tests` folder holds the validation tests that must pass before a new version is published. They run against the source tree, not an installed copy. From the repository root:
+
+```
+pip install pytest
+pytest tests
+```
+
+
 ## Troubleshooting
 
 - [Troubles with installation](https://anufrievroman.gitbook.io/freepaths/installation)

{freepaths-2.5.1 → freepaths-2.6}/README.md

@@ -59,6 +59,16 @@ Alternatively, you can run FreePATHS in the mean free path sampling mode, which
 The calculated thermal conductivity will be output in the terminal. However, other statistical quantities and plots will still be calculated and output in the `Results` folder.
 
 
+## Testing
+
+The `tests` folder holds the validation tests that must pass before a new version is published. They run against the source tree, not an installed copy. From the repository root:
+
+```
+pip install pytest
+pytest tests
+```
+
+
 ## Troubleshooting
 
 - [Troubles with installation](https://anufrievroman.gitbook.io/freepaths/installation)

{freepaths-2.5.1 → freepaths-2.6}/freepaths/__main__.py

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

{freepaths-2.5.1 → freepaths-2.6}/freepaths/maps.py

@@ -5,6 +5,7 @@ from scipy.constants import k as k_B
 import numpy as np
 from freepaths.config import cf
 from freepaths.options import SimulationMode
+import freepaths.move
 
 class Maps:
     """Parent maps class with functions common to all classes below"""
@@ -182,9 +183,18 @@ class ThermalMaps(Maps):
         This first time step is unique for each phonon. This is done to simulate more relistic continious heat flow.
         """
 
+        # The phonon is recorded at the middle of the step it is about to make, not at its start.
+        # A sample stands for the whole step, and the start of the step is a first-order (left
+        # rectangle) rule: in a temperature gradient it undercounts the heat flux by a fraction
+        # step / (2 * MFP), which made the Fourier kappa low by -10% at MFP/step = 5. The midpoint
+        # is second-order accurate, so the bias disappears (tests/test_end_to_end.py, gray medium):
+        d_x, d_y, _ = freepaths.move.step(pt.theta, pt.phi, pt.speed, cf.timestep)
+        x = pt.x + d_x / 2
+        y = pt.y + d_y / 2
+
         # Calculate the index of the pixel in which we record this phonon:
-        index_x = int(((pt.x + cf.width / 2) * cf.number_of_pixels_x) // cf.width)
-        index_y = int(pt.y // (cf.length / cf.number_of_pixels_y))
+        index_x = int(((x + cf.width / 2) * cf.number_of_pixels_x) // cf.width)
+        index_y = int(y // (cf.length / cf.number_of_pixels_y))
 
         # Prevent error if the phonon is outside the structure:
         if (0 <= index_x < cf.number_of_pixels_x) and (0 <= index_y < cf.number_of_pixels_y):

{freepaths-2.5.1 → freepaths-2.6}/freepaths/output_plots.py

@@ -495,7 +495,8 @@ def plot_thermal_map():
     """Plot thermal map as color map"""
     fig = plt.figure()
     thermal_map = np.genfromtxt("Data/Thermal map.csv", unpack=False, delimiter=',', skip_header=0, encoding='utf-8')
-    thermal_map = np.flipud(thermal_map)
+    # A map one pixel wide or long is read back as a 1D array, which imshow rejects:
+    thermal_map = np.flipud(np.reshape(thermal_map, (cf.number_of_pixels_y, cf.number_of_pixels_x)))
     minimum_of_colorbar = 1e-20  # Cannot be zero!
     boundaries = [(-cf.width / 2) * 1e6, (cf.width / 2) * 1e6, 0, cf.length * 1e6]
     plt.imshow(thermal_map, cmap='hot', interpolation='none', extent=boundaries,
@@ -513,6 +514,8 @@ 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')
+    # A map one pixel wide or long is read back as a 1D array, which imshow rejects:
+    heat_flux_map = np.reshape(heat_flux_map, (cf.number_of_pixels_y, cf.number_of_pixels_x))
     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]

{freepaths-2.5.1 → freepaths-2.6}/freepaths/output_structure.py

@@ -2,7 +2,7 @@
 
 from matplotlib.patches import Rectangle
 from freepaths.config import cf
-from freepaths.scatterers import HorizontalPlane, VerticalPlane
+from freepaths.scatterers import VerticalPlane
 
 def draw_structure_top_view(cf, color_holes="white", color_back="gray"):
     """Draw shape of the structure using patches from matplotlib"""
@@ -61,10 +61,10 @@ def draw_structure_side_view(cf, color_holes="white", color_back="gray"):
         )
     ]
 
-    # Interfaces as white patches:
-    for interface in cf.interfaces:
-        if isinstance(interface, HorizontalPlane):
-            patch = interface.get_patch(color_holes, cf)
-            patches.extend(patch if isinstance(patch, list) else [patch])
+    # Interfaces as white patches (only HorizontalPlane is visible in this view; it is disabled for now):
+    # for interface in cf.interfaces:
+    #     if isinstance(interface, HorizontalPlane):
+    #         patch = interface.get_patch(color_holes, cf)
+    #         patches.extend(patch if isinstance(patch, list) else [patch])
 
     return patches

{freepaths-2.5.1 → freepaths-2.6}/freepaths/run_particle.py

@@ -100,8 +100,11 @@ def run_particle(particle, flight, scatter_stats, places_stats, segment_stats, t
         # If interface transmission has occurred, record it:
         if scattering_types.interfaces_transmission:
             places_stats.save_scattering_events(particle, scattering_types.interfaces_transmission)
-        else:
-            flight.add_step(cf.timestep)
+
+        # The particle moves on every timestep, so its free path and scattering clock advance on every
+        # timestep too (they used to skip timesteps with an interface transmission, losing one step of
+        # free path per transmission):
+        flight.add_step(cf.timestep)
 
 
         # Record presence of the particle at this timestep and move on:

{freepaths-2.5.1 → freepaths-2.6}/freepaths/scatterers.py

@@ -572,10 +572,8 @@ class ParabolaTop(Hole):
 
         # Specular scattering:
         if random() < p:
-            if abs(pt.theta) > pi / 2:
-                pt.theta = pt.theta - 2 * normal_theta
-            else:
-                pt.theta = 2 * normal_theta - pt.theta
+            # Mirror about the tangent, whose angle is normal_theta (the same form as ParabolaBottom):
+            pt.theta = 2 * normal_theta - pt.theta
             scattering_types.walls = Scattering.SPECULAR
 
         # Diffuse scattering:
@@ -583,8 +581,7 @@ class ParabolaTop(Hole):
             scattering_types.walls = Scattering.DIFFUSE
             for _ in range(10):
                 # Lambert distribution
-                pt.theta = normal_theta + asin(2 * random() - 1) - pi / 2
-                pt.phi = asin((asin(2 * random() - 1)) / (pi / 2))
+                pt.theta, pt.phi = lambert_angles(normal_theta - pi / 2)
 
                 # Accept the angles only if they do not immediately cause new scattering:
                 if no_new_scattering(pt, cf):
@@ -632,8 +629,7 @@ class ParabolaBottom(Hole):
             scattering_types.walls = Scattering.DIFFUSE
             for _ in range(10):
                 # Lambertian distribution
-                pt.theta = normal_theta + asin(2 * random() - 1) - pi / 2
-                pt.phi = asin((asin(2 * random() - 1)) / (pi / 2))
+                pt.theta, pt.phi = lambert_angles(normal_theta - pi / 2)
 
                 # Accept the angles only if they do not immediately cause new scattering:
                 if no_new_scattering(pt, cf):
@@ -754,7 +750,9 @@ class VerticalPlane(Interface):
 
         self.assign_materials(cf)
 
-        theta_i = np.pi / 2 - pt.theta # because in the paper is the projection angle of the x axis
+        # Angle of incidence from the interface normal (x) in 3D. The in-plane pi/2 - theta alone ignored phi,
+        # treating out-of-plane phonons as closer to normal incidence than they are:
+        theta_i = np.arccos(abs(np.cos(pt.phi) * np.sin(pt.theta)))
 
         mat_0 = self.outer_material
         mat_j = self.inner_material
@@ -789,7 +787,6 @@ class VerticalPlane(Interface):
         """
         # Crossing the interface:
         transmission = self.transmission_probability(cf, pt)
-        theta_i = np.pi / 2 - pt.theta # because in the paper is the projection angle of the x axis
 
         # else:
         if random() < transmission:
@@ -823,36 +820,40 @@ class VerticalPlane(Interface):
         )
 
 
-class HorizontalPlane(Interface):
-    """Horizontal plane that represents an interface"""
-
-    def __init__(self, position_z=0, transmission=0):
-        self.position_z = position_z
-        self.transmission = transmission
-
-    def is_crossed(self, pt, x, y, z):
-        """Check if particle with traverses the vertical plane at given coordinate"""
-        return (pt.z < self.position_z < z) or (pt.z > self.position_z > z)
-
-    def is_transmitted(self):
-        """Check if particle traverses the plane given the transmission probability"""
-        return random() < self.transmission
-
-    def scatter(self, pt, scattering_types, x, y, z, cf):
-        """Calculate the new direction after scattering on the interface wall"""
-
-        # Scattering on the left wall:
-        if z < self.position_z:
-            scattering_types.interfaces = horizontal_surface_up_scattering(pt, cf.interface_roughness, cf)
-
-        # Scattering on the right wall:
-        else:
-            scattering_types.interfaces = horizontal_surface_down_scattering(pt, cf.interface_roughness, cf)
-
-    def get_patch(self, color_holes, cf):
-        """Create a patch in the shape of a thin line to use in the plots"""
-        return Rectangle(
-            (0, 1e6 * self.position_z),
-            1e6 * cf.length, 1e6 * 0.005*cf.thickness,
-            facecolor=color_holes,
-        )
+# HorizontalPlane is disabled until it is fixed. It cannot run as written: scattering.py calls
+# interface.scatter(pt, cf, scattering_types), which does not match its signature below; it scatters a
+# z-normal plane with the y-normal horizontal_surface_*_scattering functions; and it passes cf into
+# their is_diffuse slot, which would make every event diffuse.
+# class HorizontalPlane(Interface):
+#     """Horizontal plane that represents an interface"""
+#
+#     def __init__(self, position_z=0, transmission=0):
+#         self.position_z = position_z
+#         self.transmission = transmission
+#
+#     def is_crossed(self, pt, x, y, z):
+#         """Check if particle with traverses the vertical plane at given coordinate"""
+#         return (pt.z < self.position_z < z) or (pt.z > self.position_z > z)
+#
+#     def is_transmitted(self):
+#         """Check if particle traverses the plane given the transmission probability"""
+#         return random() < self.transmission
+#
+#     def scatter(self, pt, scattering_types, x, y, z, cf):
+#         """Calculate the new direction after scattering on the interface wall"""
+#
+#         # Scattering on the left wall:
+#         if z < self.position_z:
+#             scattering_types.interfaces = horizontal_surface_up_scattering(pt, cf.interface_roughness, cf)
+#
+#         # Scattering on the right wall:
+#         else:
+#             scattering_types.interfaces = horizontal_surface_down_scattering(pt, cf.interface_roughness, cf)
+#
+#     def get_patch(self, color_holes, cf):
+#         """Create a patch in the shape of a thin line to use in the plots"""
+#         return Rectangle(
+#             (0, 1e6 * self.position_z),
+#             1e6 * cf.length, 1e6 * 0.005*cf.thickness,
+#             facecolor=color_holes,
+#         )

{freepaths-2.5.1 → freepaths-2.6}/freepaths/scattering.py

@@ -11,6 +11,7 @@ from freepaths.config import cf
 from freepaths.move import move
 from freepaths.scattering_primitives import *
 from freepaths.options import ParticleType
+from freepaths.scattering_types import ScatteringTypes
 
 
 def internal_scattering(pt, flight, scattering_types):
@@ -95,8 +96,38 @@ def ceiling_scattering(pt, scattering_types, x, y, z, depletion=0.0):
         scattering_types.top_bottom = in_plane_surface_scattering(pt, cf.top_roughness)
 
 
+# A scattering event changes the direction, and the new direction can cross a boundary that was
+# checked with the old one: e.g. a diffuse redraw on the ceiling right next to a side wall points
+# straight out through the wall. So the boundaries are checked again with every new direction,
+# up to this many passes, until the step is clear:
+MAX_SCATTERING_PASSES = 4
+
+
 def surface_scattering(pt, scattering_types, triangle_scattering_places):
-    """Check for a surface scattering on this step"""
+    """Check for a surface scattering on this step, until the step with the final direction is clear"""
+    direction = (pt.theta, pt.phi)
+    _surface_scattering_pass(pt, scattering_types, triangle_scattering_places)
+
+    # Only a step whose direction was changed by a scattering event needs another look (a few % of steps):
+    for _ in range(MAX_SCATTERING_PASSES - 1):
+        if (pt.theta, pt.phi) == direction:
+            break
+        direction = (pt.theta, pt.phi)
+        this_pass = ScatteringTypes()
+        # An interface already met on this step is not met again: a transmitted particle still has to
+        # cross the plane, and that crossing is the transmission itself, not a second encounter:
+        _surface_scattering_pass(pt, this_pass, triangle_scattering_places,
+                                 check_interfaces=scattering_types.interfaces is None)
+        for name, value in vars(this_pass).items():
+            if value is not None:
+                setattr(scattering_types, name, value)
+
+    # Correct angle if it became more than 180 degrees:
+    pt.correct_angle()
+
+
+def _surface_scattering_pass(pt, scattering_types, triangle_scattering_places, check_interfaces=True):
+    """Check every boundary once against the step with the current direction"""
 
     # Preliminary move to see if particle would cross something:
     x, y, z = move(pt, cf.timestep)
@@ -140,7 +171,7 @@ def surface_scattering(pt, scattering_types, triangle_scattering_places):
                 break
 
     # Scattering on interfaces (thin layers):
-    if cf.interfaces:
+    if cf.interfaces and check_interfaces:
         for interface in cf.interfaces:
             if interface.is_crossed(pt, x, y, z):
                 interface.scatter(pt, cf, scattering_types)
@@ -148,6 +179,3 @@ def surface_scattering(pt, scattering_types, triangle_scattering_places):
             # If there was any scattering, then no need to check other interfaces:
             if scattering_types.interfaces is not None:
                 break
-
-    # Correct angle if it became more than 180 degrees:
-    pt.correct_angle()

{freepaths-2.5.1 → freepaths-2.6}/freepaths/scattering_interfaces.py

@@ -1,6 +1,6 @@
 """Module that provides scattering functions on through the interfaces made of other materials"""
 
-from math import pi, cos, sin, asin, acos
+from math import pi, cos, sin, acos
 from random import random
 
 from freepaths.scattering_types import Scattering
@@ -8,7 +8,7 @@ from freepaths.scattering_types import Scattering
 # Single definitions, shared with the free-surface primitives. They used to be duplicated
 # here verbatim, and since scatterers.py star-imports both modules this copy shadowed the
 # original, so any change to the Soffer equation had to be made twice to take effect.
-from freepaths.scattering_primitives import specularity, no_new_scattering
+from freepaths.scattering_primitives import specularity, no_new_scattering, lambert_angles
 
 
 def vertical_surface_left_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_diffuse=False):
@@ -18,7 +18,9 @@ def vertical_surface_left_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_diff
     a = acos(cos(pt.phi)*sin(abs(pt.theta)))
     p = specularity(a, roughness, pt)
 
-    theta_i = pi / 2 - pt.theta # because in the paper is the projection angle of the x axis
+    # Angle of incidence from the interface normal (x) in 3D. The in-plane pi/2 - theta alone ignored phi,
+    # treating out-of-plane phonons as closer to normal incidence than they are:
+    theta_i = acos(abs(cos(pt.phi) * sin(pt.theta)))
 
     # Specular scattering:
     if random() < p and (not is_diffuse):
@@ -40,13 +42,13 @@ def vertical_surface_left_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_diff
     # Diffuse scattering:
     else:
 
-        # Lambert cosine distribution:
-        pt.theta = -pi/2 + asin(2*random() - 1)
-        pt.phi = asin((asin(2*random() - 1))/(pi/2))
-
-        # Accept the angles if they do not cause new scattering:
-        if no_new_scattering(pt, cf):
-            return Scattering.DIFFUSE
+        # Lambert cosine distribution, redrawn if the new direction would immediately leave the domain
+        # (near an edge with the ceiling or floor). The event is diffuse whatever the draw:
+        for attempt in range(10):
+            pt.theta, pt.phi = lambert_angles(-pi/2)
+            if no_new_scattering(pt, cf):
+                break
+        return Scattering.DIFFUSE
 
 
 def vertical_surface_right_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_diffuse=False):
@@ -56,7 +58,9 @@ def vertical_surface_right_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_dif
     a = acos(cos(pt.phi)*sin(abs(pt.theta)))
     p = specularity(a, roughness, pt)
 
-    theta_i = pi / 2 - pt.theta # because in the paper is the projection angle of the x axis
+    # Angle of incidence from the interface normal (x) in 3D. The in-plane pi/2 - theta alone ignored phi,
+    # treating out-of-plane phonons as closer to normal incidence than they are:
+    theta_i = acos(abs(cos(pt.phi) * sin(pt.theta)))
 
     # Specular scattering:
     if random() < p and (not is_diffuse):
@@ -75,10 +79,10 @@ def vertical_surface_right_scattering_2T(pt, roughness, cf, vg_i_to_vg_j, is_dif
     # Diffuse scattering:
     else:
 
-        # Lambert cosine distribution:
-        pt.theta = +pi/2 + asin(2*random() - 1)
-        pt.phi = asin((asin(2*random() - 1))/(pi/2))
-
-        # Accept the angles if they do not cause new scattering:
-        if no_new_scattering(pt, cf):
-            return Scattering.DIFFUSE
+        # Lambert cosine distribution, redrawn if the new direction would immediately leave the domain
+        # (near an edge with the ceiling or floor). The event is diffuse whatever the draw:
+        for attempt in range(10):
+            pt.theta, pt.phi = lambert_angles(+pi/2)
+            if no_new_scattering(pt, cf):
+                break
+        return Scattering.DIFFUSE

{freepaths-2.5.1 → freepaths-2.6}/freepaths/scattering_primitives.py

@@ -1,6 +1,6 @@
 """Module that provides scattering functions on basic objects like various walls"""
 
-from math import pi, cos, sin, tan, exp, atan, asin, acos
+from math import pi, cos, sin, tan, exp, atan, atan2, asin, acos, sqrt
 from random import random
 from numpy import sign
 
@@ -26,6 +26,27 @@ def no_new_scattering(pt, cf):
     return abs(z) < cf.thickness / 2 and abs(x) < cf.width / 2 and cf.length > y > 0
 
 
+def lambert_angles(normal_theta, normal_phi=0.0):
+    """
+    Draw a direction from the Lambert cosine law about the surface normal
+    given by (normal_theta, normal_phi), in the direction convention of move.py:
+    d = (sin(theta)*cos(phi), cos(theta)*cos(phi), sin(phi)).
+    The cosine to the normal is mu = sqrt(random()) (density 2*mu), and the azimuth
+    around the normal is uniform. Returns the (theta, phi) of the new direction.
+    """
+    mu = sqrt(random())
+    s = sqrt(1 - mu**2)
+    psi = 2*pi*random()
+    sin_t, cos_t = sin(normal_theta), cos(normal_theta)
+    sin_p, cos_p = sin(normal_phi), cos(normal_phi)
+
+    # Normal and two unit tangents (along d/dtheta and d/dphi of the normal):
+    d_x = mu*sin_t*cos_p + s*cos(psi)*cos_t - s*sin(psi)*sin_t*sin_p
+    d_y = mu*cos_t*cos_p - s*cos(psi)*sin_t - s*sin(psi)*cos_t*sin_p
+    d_z = mu*sin_p + s*sin(psi)*cos_p
+    return atan2(d_x, d_y), asin(max(-1.0, min(1.0, d_z)))
+
+
 def random_scattering(pt):
     """Scattering in a random direction"""
     pt.theta = -pi + random()*2*pi
@@ -48,13 +69,13 @@ def vertical_surface_left_scattering(pt, roughness, cf, is_diffuse=False):
     # Diffuse scattering
     else:
 
-        # Lambert cosine distribution:
-        pt.theta = -pi/2 + asin(2*random() - 1)
-        pt.phi = asin((asin(2*random() - 1))/(pi/2))
-
-        # Accept the angles if they do not cause new scattering:
-        if no_new_scattering(pt, cf):
-            return Scattering.DIFFUSE
+        # Lambert cosine distribution, redrawn if the new direction would immediately leave the domain
+        # (near an edge with the ceiling or floor). The event is diffuse whatever the draw:
+        for attempt in range(10):
+            pt.theta, pt.phi = lambert_angles(-pi/2)
+            if no_new_scattering(pt, cf):
+                break
+        return Scattering.DIFFUSE
 
 
 def vertical_surface_right_scattering(pt, roughness, cf, is_diffuse=False):
@@ -72,13 +93,13 @@ def vertical_surface_right_scattering(pt, roughness, cf, is_diffuse=False):
     # Diffuse scattering:
     else:
 
-        # Lambert cosine distribution:
-        pt.theta = +pi/2 + asin(2*random() - 1)
-        pt.phi = asin((asin(2*random() - 1))/(pi/2))
-
-        # Accept the angles if they do not cause new scattering:
-        if no_new_scattering(pt, cf):
-            return Scattering.DIFFUSE
+        # Lambert cosine distribution, redrawn if the new direction would immediately leave the domain
+        # (near an edge with the ceiling or floor). The event is diffuse whatever the draw:
+        for attempt in range(10):
+            pt.theta, pt.phi = lambert_angles(+pi/2)
+            if no_new_scattering(pt, cf):
+                break
+        return Scattering.DIFFUSE
 
 
 def horizontal_surface_down_scattering(pt, roughness, is_diffuse=False):
@@ -95,9 +116,7 @@ def horizontal_surface_down_scattering(pt, roughness, is_diffuse=False):
 
     # Diffuse scattering:
     # Lambert cosine distribution:
-    rand_sign = sign((2*random() - 1))
-    pt.theta = rand_sign*pi/2 + rand_sign*acos(random())
-    pt.phi = asin((asin(2*random() - 1))/(pi/2))
+    pt.theta, pt.phi = lambert_angles(pi)
     return Scattering.DIFFUSE
 
 
@@ -115,16 +134,16 @@ def horizontal_surface_up_scattering(pt, roughness, is_diffuse=False):
 
     # Diffuse scattering:
     # Lambert cosine distribution:
-    pt.theta = asin(2*random() - 1)
-    pt.phi = asin((asin(2*random() - 1))/(pi/2))
+    pt.theta, pt.phi = lambert_angles(0)
     return Scattering.DIFFUSE
 
 
 def inclined_surfaces_down_scattering(pt, beta, x, x0, roughness):
     """Scattering from a inclined surfaces pointing down like V"""
 
-    # Calculate angle to the surface and specular scattering probability:
-    a = acos(cos(pt.phi)*cos(pi/2 - abs(pt.theta) - beta))
+    # Calculate angle to the surface normal and specular scattering probability:
+    normal_theta = pi - sign(x - x0)*(pi/2 - beta)
+    a = acos(abs(cos(pt.phi)*cos(pt.theta - normal_theta)))
     p = specularity(a, roughness, pt)
 
     # Specular scattering:
@@ -133,17 +152,16 @@ def inclined_surfaces_down_scattering(pt, beta, x, x0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    rand_sign = sign((2*random() - 1))
-    pt.theta = rand_sign*pi - rand_sign*asin(random()) - sign(x - x0)*(pi/2 - beta)
-    pt.phi = asin((asin(2*random() - 1))/(pi/2))
+    pt.theta, pt.phi = lambert_angles(normal_theta)
     return Scattering.DIFFUSE
 
 
 def inclined_surfaces_up_scattering(pt, beta, x, x0, roughness):
     """Scattering from a inclined surfaces pointing up like ^"""
 
-    # Calculate angle to the surface and specular scattering probability:
-    a = acos(cos(pt.phi)*cos(pi/2 - abs(pt.theta) + beta))
+    # Calculate angle to the surface normal and specular scattering probability:
+    normal_theta = sign(x - x0)*(pi/2 - beta)
+    a = acos(abs(cos(pt.phi)*cos(pt.theta - normal_theta)))
     p = specularity(a, roughness, pt)
 
     # Specular scattering:
@@ -152,8 +170,7 @@ def inclined_surfaces_up_scattering(pt, beta, x, x0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    pt.theta = asin(2*random() - 1) + sign(x - x0)*(pi/2 - beta)
-    pt.phi = asin((asin(2*random() - 1))/(pi/2))
+    pt.theta, pt.phi = lambert_angles(normal_theta)
     return Scattering.DIFFUSE
 
 
@@ -175,8 +192,7 @@ def in_plane_surface_scattering(pt, roughness):
     # phi = -asin(random())
 
     # Lambert cosine distribution:
-    pt.theta = - pi + random()*2*pi
-    pt.phi = - sign(pt.phi) *  random()*pi/2
+    pt.theta, pt.phi = lambert_angles(0, -sign(pt.phi)*pi/2)
     return Scattering.DIFFUSE
 
 
@@ -200,8 +216,7 @@ def circle_outer_scattering(pt, tangent_theta, y, y0, roughness, cf):
         # phi = asin(2*random() - 1)
 
         # Lambert cosine distribution:
-        pt.theta = tangent_theta - (asin(2*random() - 1)) - pi*(y < y0)
-        pt.phi = asin((asin(2*random() - 1))/(pi/2))
+        pt.theta, pt.phi = lambert_angles(tangent_theta - pi*(y < y0))
 
         # Accept the angles only if they do not immediately cause new scattering:
         if no_new_scattering(pt, cf):
@@ -211,7 +226,8 @@ def circle_outer_scattering(pt, tangent_theta, y, y0, roughness, cf):
 def circle_inner_scattering(pt, tangent_theta, y, y0, roughness):
     """Scattering from the inner surface of the circle"""
 
-    a = atan(tan((pi/2 - pt.theta) + tangent_theta) * cos(pt.phi))
+    # Calculate angle to the surface normal (radial, at angle tangent_theta up to pi) and specular scattering probability:
+    a = acos(abs(cos(pt.phi)*cos(pt.theta - tangent_theta)))
     p = specularity(a, roughness, pt)
 
     # Specular scattering:
@@ -220,8 +236,7 @@ def circle_inner_scattering(pt, tangent_theta, y, y0, roughness):
         return Scattering.SPECULAR
 
     # Diffuse scattering:
-    pt.theta = tangent_theta - asin(2*random()-1) + pi*(y >= y0)
-    pt.phi = asin((asin(2*random() - 1))/(pi/2))
+    pt.theta, pt.phi = lambert_angles(tangent_theta + pi*(y >= y0))
     return Scattering.DIFFUSE
 
 

{freepaths-2.5.1 → freepaths-2.6}/freepaths/sources.py

@@ -5,6 +5,8 @@ import enum
 from random import random
 from math import pi, asin
 
+from freepaths.scattering_primitives import lambert_angles
+
 
 class Distributions(enum.Enum):
     """Possible distributions of angles"""
@@ -42,8 +44,7 @@ class Source:
             theta = self.angle + 1e-10
             phi = -pi/2 + pi*random()
         elif self.angle_distribution == Distributions.LAMBERT:
-            theta = asin(2*random() - 1) + self.angle
-            phi = asin((asin(2*random() - 1))/(pi/2))
+            theta, phi = lambert_angles(self.angle)
         elif self.angle_distribution == Distributions.UNIFORM:
             theta = -pi + 2*pi*random()
             phi = asin(2*random() - 1)