Repository: uncscode/particula

Issue:
Add Microscale Time Functions
## $\tau_T$: Lagrangian Taylor Microscale Time

Time correlation decay for turbulent trajectories:

$$
\tau_T = \tau_k \left(\frac{2 R_\lambda}{15^{1/2} a_o}\right)^{1/2}
$$

### $\lambda$: Taylor Microscale

Length scale linked to fluid flow:

$$
\lambda = u' \left(\frac{15 \nu^2}{\epsilon}\right)^{1/2}
$$


Discussion:
sourcery-ai[bot]: <!-- Generated by sourcery-ai[bot]: start review_guide -->

🧙 Sourcery is reviewing your pull request!

---

<details>
<summary>Tips and commands</summary>

#### Interacting with Sourcery

- **Trigger a new review:** Comment `@sourcery-ai review` on the pull request.
- **Continue discussions:** Reply directly to Sourcery's review comments.
- **Generate a GitHub issue from a review comment:** Ask Sourcery to create an
  issue from a review comment by replying to it.
- **Generate a pull request title:** Write `@sourcery-ai` anywhere in the pull
  request title to generate a title at any time.
- **Generate a pull request summary:** Write `@sourcery-ai summary` anywhere in
  the pull request body to generate a PR summary at any time. You can also use
  this command to specify where the summary should be inserted.

#### Customizing Your Experience

Access your [dashboard](https://app.sourcery.ai) to:
- Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
- Change the review language.
- Add, remove or edit custom review instructions.
- Adjust other review settings.

#### Getting Help

- [Contact our support team](mailto:support@sourcery.ai) for questions or feedback.
- Visit our [documentation](https://docs.sourcery.ai) for detailed guides and information.
- Keep in touch with the Sourcery team by following us on [X/Twitter](https://x.com/SourceryAI), [LinkedIn](https://www.linkedin.com/company/sourcery-ai/) or [GitHub](https://github.com/sourcery-ai).

</details>

<!-- Generated by sourcery-ai[bot]: end review_guide -->
github-actions[bot]: [PR Preview Action](https://github.com/rossjrw/pr-preview-action) v1.6.0
:---:
| <p></p> :rocket: View preview at <br> https://uncscode.github.io/particula/pr-preview/pr-582/ <br><br>
| <h6>Built to branch [`gh-pages`](https://github.com/uncscode/particula/tree/gh-pages) at 2025-01-19 00:22 UTC. <br> Preview will be ready when the [GitHub Pages deployment](https://github.com/uncscode/particula/deployments) is complete. <br><br> </h6>
<!-- Sticky Pull Request Commentpr-preview -->

Patch:
diff --git a/particula/dynamics/coagulation/turbulent_dns_kernel/__init__.py b/particula/dynamics/coagulation/turbulent_dns_kernel/__init__.py
new file mode 100644
index 000000000..5eccdbc4c
--- /dev/null
+++ b/particula/dynamics/coagulation/turbulent_dns_kernel/__init__.py
@@ -0,0 +1,5 @@
+"""Geometric DNS Kernel functions exposed via __init__.
+
+If you want specific sub functions, import them directly from
+`particula.next.dynamics.coagulation.xxx.xxx` instead.
+"""
diff --git a/particula/dynamics/coagulation/turbulent_shear_kernel.py b/particula/dynamics/coagulation/turbulent_shear_kernel.py
index dfba7a22b..52f16a5cc 100644
--- a/particula/dynamics/coagulation/turbulent_shear_kernel.py
+++ b/particula/dynamics/coagulation/turbulent_shear_kernel.py
@@ -24,7 +24,7 @@ from particula.gas.properties.kinematic_viscosity import (
 
 
 def saffman_turner_1956(
-    diameter_particle: NDArray[np.float64],
+    particle_radius: NDArray[np.float64],
     turbulent_kinetic_energy: float,
     kinematic_viscosity: float,
 ) -> NDArray[np.float64]:
@@ -33,7 +33,7 @@ def saffman_turner_1956(
 
     Args:
     -----
-        - diameter_particle : Array of particle diameters [m].
+        - particle_radius : Array of particle radii [m].
         - turbulent_kinetic_energy : Turbulent kinetic energy [m^2/s^2].
         - kinematic_viscosity : Kinematic viscosity [m^2/s].
 
@@ -55,15 +55,16 @@ def saffman_turner_1956(
         physics, Chapter 13, Equation 13A.2.
     """
     diameter_sum_matrix = (
-        diameter_particle[:, np.newaxis] + diameter_particle[np.newaxis, :]
-    )
+        particle_radius[:, np.newaxis] + particle_radius[np.newaxis, :]
+    ) * 2  # Convert from radius to diameter sum
+
     return (
         np.pi * turbulent_kinetic_energy / (120 * kinematic_viscosity)
     ) ** 0.5 * diameter_sum_matrix**3
 
 
 def saffman_turner_1956_via_system_state(
-    diameter_particle: NDArray[np.float64],
+    particle_radius: NDArray[np.float64],
     turbulent_kinetic_energy: float,
     temperature: float,
     fluid_density: float,
@@ -73,7 +74,7 @@ def saffman_turner_1956_via_system_state(
 
     Args:
     -----
-        - diameter_particle : Array of particle diameters [m].
+        - particle_radius : Array of particle radii [m].
         - turbulent_kinetic_energy : Turbulent kinetic energy [m^2/s^2].
         - temperature : Temperature of the system [K].
         - fluid_density : Density of the fluid [kg/m^3].
@@ -92,7 +93,7 @@ def saffman_turner_1956_via_system_state(
         temperature=temperature, fluid_density=fluid_density
     )
     return saffman_turner_1956(
-        diameter_particle=diameter_particle,
+        particle_radius=particle_radius,
         turbulent_kinetic_energy=turbulent_kinetic_energy,
         kinematic_viscosity=kinematic_viscosity,
     )
diff --git a/particula/gas/properties/__init__.py b/particula/gas/properties/__init__.py
index 1af830aca..b4eeb3f26 100644
--- a/particula/gas/properties/__init__.py
+++ b/particula/gas/properties/__init__.py
@@ -26,6 +26,19 @@ from particula.gas.properties.vapor_pressure_module import (
     clausius_clapeyron_vapor_pressure,
     buck_vapor_pressure,
 )
-from particula.gas.properties.kolmogorov_time import (
-    get_kolmogorov_time
+from particula.gas.properties.kolmogorov_module import (
+    get_kolmogorov_time,
+    get_kolmogorov_length,
+    get_kolmogorov_velocity,
+)
+from particula.gas.properties.integral_scale_module import (
+    get_lagrangian_integral_scale,
+    get_eulerian_integral_scale,
+)
+from particula.gas.properties.fluid_rms_velocity import (
+    get_fluid_rms_velocity
+)
+from particula.gas.properties.taylor_microscale_module import (
+    get_lagrangian_taylor_microscale_time,
+    get_taylor_microscale,
 )
diff --git a/particula/gas/properties/fluid_rms_velocity.py b/particula/gas/properties/fluid_rms_velocity.py
new file mode 100644
index 000000000..8faee8640
--- /dev/null
+++ b/particula/gas/properties/fluid_rms_velocity.py
@@ -0,0 +1,54 @@
+"""
+Fluid RMS fluctuation velocity calculation module.
+"""
+
+from typing import Union
+from numpy.typing import NDArray
+import numpy as np
+
+from particula.util.validate_inputs import validate_inputs
+from particula.gas.properties.kolmogorov_module import get_kolmogorov_velocity
+
+
+@validate_inputs(
+    {
+        "re_lambda": "positive",
+        "kinematic_viscosity": "positive",
+        "turbulent_dissipation": "positive",
+    }
+)
+def get_fluid_rms_velocity(
+    re_lambda: Union[float, NDArray[np.float64]],
+    kinematic_viscosity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the fluid RMS fluctuation velocity.
+
+    The fluid root-mean-square (RMS) velocity fluctuation quantifies
+    turbulence intensity in a fluid flow. It is calculated as:
+
+        u' = (R_λ^(1/2) v_K) / 15^(1/4)
+
+    - u' : Fluid RMS fluctuation velocity [m/s]
+    - R_λ (re_lambda) : Taylor-microscale Reynolds number [-]
+    - v_K : Kolmogorov velocity scale, computed as v_K = ( ε)^(1/4) [m/s]
+    - v (kinematic_viscosity) : Kinematic viscosity of the fluid [m²/s]
+    - ε (turbulent_dissipation) : Turbulent energy dissipation rate [m²/s³]
+
+
+    Arguments:
+    ----------
+        - re_lambda : Taylor-microscale Reynolds number [-]
+        - kinematic_viscosity : Kinematic viscosity of the fluid [m²/s]
+        - turbulent_dissipation : Rate of dissipation of turbulent kinetic
+            energy [m²/s³]
+
+    Returns:
+    --------
+        - Fluid RMS fluctuation velocity [m/s]
+    """
+    kolmogorov_velocity = get_kolmogorov_velocity(
+        kinematic_viscosity, turbulent_dissipation
+    )
+    return (re_lambda**0.5 * kolmogorov_velocity) / (15**0.25)
diff --git a/particula/gas/properties/integral_scale_module.py b/particula/gas/properties/integral_scale_module.py
new file mode 100644
index 000000000..96d6ef456
--- /dev/null
+++ b/particula/gas/properties/integral_scale_module.py
@@ -0,0 +1,77 @@
+"""
+Calculate a fluids integral scale.
+"""
+
+from typing import Union
+from numpy.typing import NDArray
+import numpy as np
+
+from particula.util.validate_inputs import validate_inputs
+
+
+@validate_inputs(
+    {"rms_velocity": "positive", "turbulent_dissipation": "positive"}
+)
+def get_lagrangian_integral_scale(
+    rms_velocity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Lagrangian integral timescale.
+
+    The Lagrangian integral scale (T_L) characterizes the timescale of large
+    eddies in turbulence. This represents the correlation time of fluid
+    elements in turbulent motion. It is given by:
+
+        T_L = u'^2 / ε
+
+    where:
+        - T_L : Lagrangian integral timescale [s]
+        - u' (rms_velocity) : Fluid RMS fluctuation velocity [m/s]
+        - ε (turbulent_dissipation) : Turbulent energy dissipation rate [m²/s³]
+
+    Arguments:
+    ----------
+        - rms_velocity : Fluid RMS fluctuation velocity [m/s]
+        - turbulent_dissipation : Turbulent kinetic energy dissipation rate
+            [m²/s³]
+
+    Returns:
+    --------
+        - Lagrangian integral timescale [s]
+    """
+    return (rms_velocity**2) / turbulent_dissipation
+
+
+@validate_inputs(
+    {"rms_velocity": "positive", "turbulent_dissipation": "positive"}
+)
+def get_eulerian_integral_scale(
+    rms_velocity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Eulerian integral length scale.
+
+    The Eulerian integral length scale (L_e) represents the characteristic
+    size of the largest turbulent eddies and provides insight into the spatial
+    correlation of turbulence structures. It is given by:
+
+        L_e = 0.5 * u'^3 / ε
+
+    where:
+        - L_e : Eulerian integral length scale [m]
+        - u' (rms_velocity) : Fluid RMS fluctuation velocity [m/s]
+        - ε (turbulent_dissipation) : Turbulent energy dissipation rate [m²/s³]
+
+    Arguments:
+    ----------
+        - rms_velocity : Fluid RMS fluctuation velocity [m/s]
+        - turbulent_dissipation : Turbulent kinetic energy dissipation rate
+            [m²/s³]
+
+    Returns:
+    --------
+        - Eulerian integral length scale [m]
+    """
+    return 0.5 * (rms_velocity**3) / turbulent_dissipation
diff --git a/particula/gas/properties/kolmogorov_module.py b/particula/gas/properties/kolmogorov_module.py
new file mode 100644
index 000000000..d9e752cfc
--- /dev/null
+++ b/particula/gas/properties/kolmogorov_module.py
@@ -0,0 +1,122 @@
+"""
+Get the Kolmogorov time of a gas particle.
+
+References:
+    Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on the
+    geometric collision rate of sedimenting droplets. Part 2. Theory and
+    parameterization. New Journal of Physics, 10.
+    https://doi.org/10.1088/1367-2630/10/7/075016
+"""
+
+from typing import Union
+from numpy.typing import NDArray
+import numpy as np
+
+from particula.util.validate_inputs import validate_inputs
+
+
+@validate_inputs(
+    {"kinematic_viscosity": "positive", "turbulent_dissipation": "positive"}
+)
+def get_kolmogorov_time(
+    kinematic_viscosity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Kolmogorov time of a fluid.
+
+    The Kolmogorov time scale represents the smallest timescale in turbulence
+    where viscous forces dominate over inertial effects. This timescale
+    characterizes the turnover time of the smallest turbulent
+    eddies. It is given by:
+
+        τ_K = (v / ε)^(1/2)
+
+    Arguments:
+    ----------
+        - kinematic_viscosity : Kinematic viscosity of the fluid [m^2/s]
+        - turbulent_dissipation : Rate of dissipation of turbulent kinetic
+            energy [m^2/s^3]
+
+    Returns:
+    --------
+        - Kolmogorov time [s]
+
+    References:
+    ----------
+        - Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on
+        the geometric collision rate of sedimenting droplets. Part 2. Theory
+        and parameterization. New Journal of Physics, 10.
+        https://doi.org/10.1088/1367-2630/10/7/075016
+    """
+    return np.sqrt(kinematic_viscosity / turbulent_dissipation)
+
+
+@validate_inputs(
+    {"kinematic_viscosity": "positive", "turbulent_dissipation": "positive"}
+)
+def get_kolmogorov_length(
+    kinematic_viscosity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Kolmogorov length scale.
+
+    The Kolmogorov length scale represents the smallest eddies in a turbulent
+    flow where viscosity dominates. It is defined as:
+
+        η = (ν³ / ε)^(1/4)
+
+    Arguments:
+    ----------
+        - kinematic_viscosity : Kinematic viscosity of the fluid [m^2/s]
+        - turbulent_dissipation : Rate of dissipation of turbulent kinetic
+            energy [m^2/s^3]
+
+    Returns:
+    --------
+        - Kolmogorov length scale [m]
+
+    References:
+    ----------
+        - Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on
+        the geometric collision rate of sedimenting droplets. Part 2. Theory
+        and parameterization. New Journal of Physics, 10.
+        https://doi.org/10.1088/1367-2630/10/7/075016
+    """
+    return np.sqrt(np.sqrt(kinematic_viscosity**3 / turbulent_dissipation))
+
+
+@validate_inputs(
+    {"kinematic_viscosity": "positive", "turbulent_dissipation": "positive"}
+)
+def get_kolmogorov_velocity(
+    kinematic_viscosity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Kolmogorov velocity scale.
+
+    The Kolmogorov velocity scale characterizes the smallest turbulent velocity
+    fluctuations and is given by:
+
+        v_k = (v ε)^(1/4)
+
+    Arguments:
+    ----------
+        - kinematic_viscosity : Kinematic viscosity of the fluid [m^2/s]
+        - turbulent_dissipation : Rate of dissipation of turbulent kinetic
+            energy [m^2/s^3]
+
+    Returns:
+    --------
+        - Kolmogorov velocity scale [m/s]
+
+    References:
+    -----------
+        - Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on
+        the geometric collision rate of sedimenting droplets. Part 2. Theory
+        and parameterization. New Journal of Physics, 10.
+        https://doi.org/10.1088/1367-2630/10/7/075016
+    """
+    return (kinematic_viscosity * turbulent_dissipation) ** 0.25
diff --git a/particula/gas/properties/kolmogorov_time.py b/particula/gas/properties/kolmogorov_time.py
deleted file mode 100644
index 180e0b1f9..000000000
--- a/particula/gas/properties/kolmogorov_time.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-Get the Kolmogorov time of a gas particle.
-
-References:
-    Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on the
-    geometric collision rate of sedimenting droplets. Part 2. Theory and
-    parameterization. New Journal of Physics, 10.
-    https://doi.org/10.1088/1367-2630/10/7/075016
-"""
-
-from typing import Union
-from numpy.typing import NDArray
-import numpy as np
-
-from particula.util.validate_inputs import validate_inputs
-
-
-@validate_inputs(
-    {"kinematic_viscosity": "positive", "turbulent_dissipation": "positive"}
-)
-def get_kolmogorov_time(
-    kinematic_viscosity: Union[float, NDArray[np.float64]],
-    turbulent_dissipation: Union[float, NDArray[np.float64]],
-) -> Union[float, NDArray[np.float64]]:
-    """
-    Calculate the Kolmogorov time of a fluid.
-
-    The Kolmogorov time is the smallest timescale in turbulence where viscous
-    forces dominate. It is calculated as the square root of kinematic
-    viscosity divided by the rate of dissipation of turbulent kinetic
-    energy.
-
-    Arguments:
-    ----------
-        - kinematic_viscosity : Kinematic viscosity of the fluid [m^2/s]
-        - turbulent_dissipation : Rate of dissipation of turbulent kinetic
-            energy [m^2/s^3]
-
-    Returns:
-    --------
-        - Kolmogorov time [s]
-
-    References:
-    ----------
-        - Ayala, O., Rosa, B., & Wang, L. P. (2008). Effects of turbulence on
-        the geometric collision rate of sedimenting droplets. Part 2. Theory
-        and parameterization. New Journal of Physics, 10.
-        https://doi.org/10.1088/1367-2630/10/7/075016
-    """
-    return np.sqrt(kinematic_viscosity / turbulent_dissipation)
diff --git a/particula/gas/properties/taylor_microscale_module.py b/particula/gas/properties/taylor_microscale_module.py
new file mode 100644
index 000000000..5e4c507ca
--- /dev/null
+++ b/particula/gas/properties/taylor_microscale_module.py
@@ -0,0 +1,101 @@
+"""
+Taylor microscale module, for both the Lagrangian Taylor microscale time and
+the Taylor microscale.
+"""
+
+from typing import Union
+from numpy.typing import NDArray
+import numpy as np
+
+from particula.util.validate_inputs import validate_inputs
+
+
+@validate_inputs(
+    {
+        "kolmogorov_time": "positive",
+        "re_lambda": "positive",
+        "accel_variance": "positive",
+    }
+)
+def get_lagrangian_taylor_microscale_time(
+    kolmogorov_time: Union[float, NDArray[np.float64]],
+    re_lambda: Union[float, NDArray[np.float64]],
+    accel_variance: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Lagrangian Taylor microscale time.
+
+    The Lagrangian Taylor microscale time (τ_T) represents the characteristic
+    time for the decay of turbulent velocity correlations. It provides insight
+    into the memory of turbulent fluid elements. It is given by:
+
+        τ_T = τ_k * (2 R_λ / (15^(1/2) a_o))^(1/2)
+
+    - τ_T : Lagrangian Taylor microscale time [s]
+    - τ_k (kolmogorov_time) : Kolmogorov time scale [s]
+    - R_λ (re_lambda) : Taylor-microscale Reynolds number [-]
+    - a_o (accel_variance) : Normalized acceleration variance in isotropic
+        turbulence [-]
+
+    Arguments:
+    ----------
+        - kolmogorov_time : Kolmogorov time scale [s]
+        - re_lambda : Taylor-microscale Reynolds number [-]
+        - accel_variance : Normalized acceleration variance in isotropic
+            turbulence [-]
+
+    Returns:
+    --------
+        - Lagrangian Taylor microscale time [s]
+    """
+    return kolmogorov_time * np.sqrt(
+        (2 * re_lambda) / (15**0.5 * accel_variance)
+    )
+
+
+@validate_inputs(
+    {
+        "rms_velocity": "positive",
+        "kinematic_viscosity": "positive",
+        "turbulent_dissipation": "positive",
+    }
+)
+def get_taylor_microscale(
+    rms_velocity: Union[float, NDArray[np.float64]],
+    kinematic_viscosity: Union[float, NDArray[np.float64]],
+    turbulent_dissipation: Union[float, NDArray[np.float64]],
+) -> Union[float, NDArray[np.float64]]:
+    """
+    Calculate the Taylor microscale.
+
+    The Taylor microscale (λ) represents an intermediate length scale in
+    turbulence, linking the dissipative and energy-containing ranges of
+    turbulence. It characterizes the smoothness of velocity fluctuations
+    in turbulent flows. It is given by:
+
+        λ = u' * (15 ν² / ε)^(1/2)
+
+    - λ : Taylor microscale [m]
+    - u' (rms_velocity) : Fluid RMS fluctuation velocity [m/s]
+    - v (kinematic_viscosity) : Kinematic viscosity of the fluid [m²/s]
+    - ε (turbulent_dissipation) : Turbulent kinetic energy dissipation
+        rate [m²/s³]
+
+    Arguments:
+    ----------
+        - rms_velocity : Fluid RMS fluctuation velocity [m/s]
+        - kinematic_viscosity : Kinematic viscosity of the fluid [m²/s]
+        - turbulent_dissipation : Turbulent kinetic energy dissipation rate
+            [m²/s³]
+
+    Returns:
+    --------
+        - Taylor microscale [m]
+
+    References:
+    -----------
+        - https://en.wikipedia.org/wiki/Taylor_microscale
+    """
+    return rms_velocity * np.sqrt(
+        (15 * kinematic_viscosity**2) / turbulent_dissipation
+    )


Test patch:
diff --git a/particula/dynamics/coagulation/tests/turbulent_shear_kernel_test.py b/particula/dynamics/coagulation/tests/turbulent_shear_kernel_test.py
index 5b35f66a4..2696a9b38 100644
--- a/particula/dynamics/coagulation/tests/turbulent_shear_kernel_test.py
+++ b/particula/dynamics/coagulation/tests/turbulent_shear_kernel_test.py
@@ -29,7 +29,7 @@ def test_turbulent_shear_kernel_single_value():
         diameter_particle[:, np.newaxis] + diameter_particle[np.newaxis, :]
     ) ** 3
     value = saffman_turner_1956(
-        diameter_particle, turbulent_kinetic_energy, kinematic_viscosity
+        diameter_particle/2, turbulent_kinetic_energy, kinematic_viscosity
     )
     np.testing.assert_allclose(value, expected_kernel, rtol=1e-6)
 
@@ -38,7 +38,7 @@ def test_turbulent_shear_kernel_via_system_state():
     """
     Test turbulent_shear_kernel_via_system_state with system state inputs.
     """
-    diameter_particle = np.array([1e-6, 2e-6])  # example diameters [m]
+    particle_radius = np.array([1e-6, 2e-6])  # example diameters [m]
     turbulent_kinetic_energy = (
         1.0e-4  # example turbulent kinetic energy [m^2/s^2]
     )
@@ -48,10 +48,10 @@ def test_turbulent_shear_kernel_via_system_state():
         temperature=temperature, fluid_density=fluid_density
     )
     expected_kernel = saffman_turner_1956(
-        diameter_particle, turbulent_kinetic_energy, kinematic_viscosity
+        particle_radius, turbulent_kinetic_energy, kinematic_viscosity
     )
     value = saffman_turner_1956_via_system_state(
-        diameter_particle, turbulent_kinetic_energy, temperature, fluid_density
+        particle_radius, turbulent_kinetic_energy, temperature, fluid_density
     )
     np.testing.assert_allclose(value, expected_kernel, rtol=1e-6)
 
diff --git a/particula/gas/properties/tests/fluid_rms_velocity_test.py b/particula/gas/properties/tests/fluid_rms_velocity_test.py
new file mode 100644
index 000000000..01b925aa6
--- /dev/null
+++ b/particula/gas/properties/tests/fluid_rms_velocity_test.py
@@ -0,0 +1,88 @@
+"""
+Test file for fluid_rms_velocity.py.
+"""
+
+import pytest
+import numpy as np
+from particula.gas.properties.fluid_rms_velocity import (
+    get_fluid_rms_velocity,
+)  # Update 'your_module' with the actual module name
+
+
+def test_get_fluid_rms_velocity_scalar():
+    """
+    Test get_fluid_rms_velocity with scalar inputs.
+    """
+    re_lambda = 100.0
+    kinematic_viscosity = 1.5e-5  # m²/s
+    turbulent_dissipation = 1e-3  # m²/s³
+
+    expected = (
+        re_lambda**0.5 * (kinematic_viscosity * turbulent_dissipation) ** 0.25
+    ) / (15**0.25)
+    result = get_fluid_rms_velocity(
+        re_lambda, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.isclose(
+        result, expected, atol=1e-10
+    ), f"Expected {expected}, got {result}"
+
+
+def test_get_fluid_rms_velocity_array():
+    """
+    Test get_fluid_rms_velocity with NumPy array inputs.
+    """
+    re_lambda = np.array([100.0, 200.0])
+    kinematic_viscosity = np.array([1.5e-5, 1.2e-5])
+    turbulent_dissipation = np.array([1e-3, 2e-3])
+
+    expected = (
+        re_lambda**0.5 * (kinematic_viscosity * turbulent_dissipation) ** 0.25
+    ) / (15**0.25)
+    result = get_fluid_rms_velocity(
+        re_lambda, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.allclose(
+        result, expected, atol=1e-10
+    ), f"Expected {expected}, got {result}"
+
+
+def test_get_fluid_rms_velocity_invalid_values():
+    """
+    Test that get_fluid_rms_velocity raises errors for invalid inputs.
+    """
+    with pytest.raises(ValueError):
+        get_fluid_rms_velocity(-10.0, 1.5e-5, 1e-3)  # Negative Reynolds number
+
+    with pytest.raises(ValueError):
+        get_fluid_rms_velocity(
+            100.0, -1.5e-5, 1e-3
+        )  # Negative kinematic viscosity
+
+    with pytest.raises(ValueError):
+        get_fluid_rms_velocity(
+            100.0, 1.5e-5, -1e-3
+        )  # Negative turbulent dissipation
+
+
+def test_get_fluid_rms_velocity_edge_case():
+    """
+    Test get_fluid_rms_velocity with very small values close to machine
+    precision.
+    """
+    re_lambda = 1.0
+    kinematic_viscosity = 1e-10
+    turbulent_dissipation = 1e-10
+
+    expected = (
+        re_lambda**0.5 * (kinematic_viscosity * turbulent_dissipation) ** 0.25
+    ) / (15**0.25)
+    result = get_fluid_rms_velocity(
+        re_lambda, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.isclose(
+        result, expected, atol=1e-10
+    ), f"Expected {expected}, got {result}"
diff --git a/particula/gas/properties/tests/integral_scale_module_test.py b/particula/gas/properties/tests/integral_scale_module_test.py
new file mode 100644
index 000000000..97eb90718
--- /dev/null
+++ b/particula/gas/properties/tests/integral_scale_module_test.py
@@ -0,0 +1,105 @@
+"""
+Test the integral scale functions in the integral_scale_module.py file.
+"""
+
+import pytest
+import numpy as np
+from particula.gas.properties.integral_scale_module import (
+    get_lagrangian_integral_scale,
+    get_eulerian_integral_scale,
+)
+
+
+def test_get_lagrangian_integral_scale_scalar():
+    """
+    Test get_lagrangian_integral_scale with scalar inputs.
+    """
+    rms_velocity = 0.5  # m/s
+    turbulent_dissipation = 1e-3  # m²/s³
+
+    expected = (rms_velocity**2) / turbulent_dissipation
+    result = get_lagrangian_integral_scale(rms_velocity, turbulent_dissipation)
+
+    assert np.isclose(result, expected, atol=1e-10)
+
+
+def test_get_lagrangian_integral_scale_array():
+    """
+    Test get_lagrangian_integral_scale with NumPy array inputs.
+    """
+    rms_velocity = np.array([0.5, 0.8])
+    turbulent_dissipation = np.array([1e-3, 2e-3])
+
+    expected = (rms_velocity**2) / turbulent_dissipation
+    result = get_lagrangian_integral_scale(rms_velocity, turbulent_dissipation)
+
+    assert np.allclose(result, expected, atol=1e-10)
+
+
+def test_get_lagrangian_integral_scale_invalid_values():
+    """
+    Test that get_lagrangian_integral_scale raises errors for invalid inputs.
+    """
+    with pytest.raises(ValueError):
+        get_lagrangian_integral_scale(-0.5, 1e-3)
+
+    with pytest.raises(ValueError):
+        get_lagrangian_integral_scale(0.5, -1e-3)
+
+
+def test_get_eulerian_integral_scale_scalar():
+    """
+    Test get_eulerian_integral_scale with scalar inputs.
+    """
+    rms_velocity = 0.5  # m/s
+    turbulent_dissipation = 1e-3  # m²/s³
+
+    expected = 0.5 * (rms_velocity**3) / turbulent_dissipation
+    result = get_eulerian_integral_scale(rms_velocity, turbulent_dissipation)
+
+    assert np.isclose(result, expected, atol=1e-10)
+
+
+def test_get_eulerian_integral_scale_array():
+    """
+    Test get_eulerian_integral_scale with NumPy array inputs.
+    """
+    rms_velocity = np.array([0.5, 0.8])
+    turbulent_dissipation = np.array([1e-3, 2e-3])
+
+    expected = 0.5 * (rms_velocity**3) / turbulent_dissipation
+    result = get_eulerian_integral_scale(rms_velocity, turbulent_dissipation)
+
+    assert np.allclose(result, expected, atol=1e-10)
+
+
+def test_get_eulerian_integral_scale_invalid_values():
+    """
+    Test that get_eulerian_integral_scale raises errors for invalid inputs.
+    """
+    with pytest.raises(ValueError):
+        get_eulerian_integral_scale(-0.5, 1e-3)
+
+    with pytest.raises(ValueError):
+        get_eulerian_integral_scale(0.5, -1e-3)
+
+
+def test_integral_scales_edge_case():
+    """
+    Test both integral scale functions with very small values near machine precision.
+    """
+    rms_velocity = 1e-10
+    turbulent_dissipation = 1e-10
+
+    expected_tl = (rms_velocity**2) / turbulent_dissipation
+    expected_le = 0.5 * (rms_velocity**3) / turbulent_dissipation
+
+    result_tl = get_lagrangian_integral_scale(
+        rms_velocity, turbulent_dissipation
+    )
+    result_le = get_eulerian_integral_scale(
+        rms_velocity, turbulent_dissipation
+    )
+
+    assert np.isclose(result_tl, expected_tl, atol=1e-10)
+    assert np.isclose(result_le, expected_le, atol=1e-10)
diff --git a/particula/gas/properties/tests/kolmogorov_module_test.py b/particula/gas/properties/tests/kolmogorov_module_test.py
new file mode 100644
index 000000000..6bb1078a2
--- /dev/null
+++ b/particula/gas/properties/tests/kolmogorov_module_test.py
@@ -0,0 +1,83 @@
+"""Test Kolmogorov Properties"""
+
+import numpy as np
+import pytest
+from particula.gas.properties.kolmogorov_module import (
+    get_kolmogorov_time,
+    get_kolmogorov_length,
+    get_kolmogorov_velocity,
+)
+
+
+def test_kolmogorov_time_float():
+    """
+    Test kolmogorov_time with float inputs.
+    """
+    assert np.isclose(get_kolmogorov_time(1.0, 1.0), 1.0)
+    assert np.isclose(get_kolmogorov_time(0.01, 0.01), 1.0)
+    assert np.isclose(get_kolmogorov_time(0.1, 0.01), 3.1622776601683795)
+
+
+def test_kolmogorov_time_array():
+    """
+    Test kolmogorov_time with numpy array inputs.
+    """
+    kinematic_viscosity = np.array([1.0, 0.01, 0.1])
+    turbulent_dissipation = np.array([1.0, 0.01, 0.01])
+    expected = np.array([1.0, 1.0, 3.1622776601683795])
+    result = get_kolmogorov_time(kinematic_viscosity, turbulent_dissipation)
+    assert np.allclose(result, expected)
+
+
+def test_kolmogorov_time_input_range():
+    """
+    Test kolmogorov_time with invalid input ranges.
+    """
+    with pytest.raises(ValueError):
+        get_kolmogorov_time(-1.0, 1.0)
+    with pytest.raises(ValueError):
+        get_kolmogorov_time(1.0, -1.0)
+    with pytest.raises(ValueError):
+        get_kolmogorov_time(-1.0, -1.0)
+
+
+def test_kolmogorov_length_float():
+    """
+    Test kolmogorov_length with float inputs.
+    """
+    assert np.isclose(get_kolmogorov_length(1.0, 1.0), 1.0)
+    assert np.isclose(get_kolmogorov_length(0.01, 0.01), 0.1)
+    assert np.isclose(get_kolmogorov_length(0.1, 0.01), 0.5623413251903491)
+
+
+def test_kolmogorov_length_array():
+    """
+    Test kolmogorov_length with numpy array inputs.
+    """
+    kinematic_viscosity = np.array([1.0, 0.01, 0.1])
+    turbulent_dissipation = np.array([1.0, 0.01, 0.01])
+    expected = np.array([1.0, 0.1, 0.5623413251903491])
+    result = get_kolmogorov_length(kinematic_viscosity, turbulent_dissipation)
+    assert np.allclose(result, expected)
+
+
+def test_kolmogorov_velocity_float():
+    """
+    Test kolmogorov_velocity with float inputs.
+    """
+    assert np.isclose(get_kolmogorov_velocity(1.0, 1.0), 1.0)
+    assert np.isclose(get_kolmogorov_velocity(0.01, 0.01), 0.1)
+    assert np.isclose(get_kolmogorov_velocity(0.1, 0.01), 0.1778279410038923)
+
+
+def test_kolmogorov_velocity_array():
+    """
+    Test kolmogorov_velocity with numpy array inputs.
+    """
+    kinematic_viscosity = np.array([1.0, 0.01, 0.1])
+    turbulent_dissipation = np.array([1.0, 0.01, 0.01])
+    expected = np.array([1.0, 0.1, 0.1778279410038923])
+    result = get_kolmogorov_velocity(
+        kinematic_viscosity, turbulent_dissipation
+    )
+    assert np.allclose(result, expected)
diff --git a/particula/gas/properties/tests/kolmogorov_time_test.py b/particula/gas/properties/tests/kolmogorov_time_test.py
deleted file mode 100644
index 3790c9180..000000000
--- a/particula/gas/properties/tests/kolmogorov_time_test.py
+++ /dev/null
@@ -1,37 +0,0 @@
-"""Test Kolmogorov Time"""
-
-import numpy as np
-import pytest
-from particula.gas.properties.kolmogorov_time import get_kolmogorov_time
-
-
-def test_kolmogorov_time_float():
-    """
-    Test kolmogorov_time with float inputs.
-    """
-    assert np.isclose(get_kolmogorov_time(1.0, 1.0), 1.0)
-    assert np.isclose(get_kolmogorov_time(0.01, 0.01), 1.0)
-    assert np.isclose(get_kolmogorov_time(0.1, 0.01), 3.1622776601683795)
-
-
-def test_kolmogorov_time_array():
-    """
-    Test kolmogorov_time with numpy array inputs.
-    """
-    kinematic_viscosity = np.array([1.0, 0.01, 0.1])
-    turbulent_dissipation = np.array([1.0, 0.01, 0.01])
-    expected = np.array([1.0, 1.0, 3.1622776601683795])
-    result = get_kolmogorov_time(kinematic_viscosity, turbulent_dissipation)
-    assert np.allclose(result, expected)
-
-
-def test_kolmogorov_time_input_range():
-    """
-    Test kolmogorov_time with invalid input ranges.
-    """
-    with pytest.raises(ValueError):
-        get_kolmogorov_time(-1.0, 1.0)
-    with pytest.raises(ValueError):
-        get_kolmogorov_time(1.0, -1.0)
-    with pytest.raises(ValueError):
-        get_kolmogorov_time(-1.0, -1.0)
diff --git a/particula/gas/properties/tests/taylor_microscale_module_test.py b/particula/gas/properties/tests/taylor_microscale_module_test.py
new file mode 100644
index 000000000..73bd0b007
--- /dev/null
+++ b/particula/gas/properties/tests/taylor_microscale_module_test.py
@@ -0,0 +1,137 @@
+"""
+Test module for the Taylor microscale functions.
+"""
+
+import pytest
+import numpy as np
+from particula.gas.properties.taylor_microscale_module import (
+    get_lagrangian_taylor_microscale_time,
+    get_taylor_microscale,
+)
+
+
+def test_get_lagrangian_taylor_microscale_time_scalar():
+    """
+    Test get_lagrangian_taylor_microscale_time with scalar inputs.
+    """
+    kolmogorov_time = 0.01  # s
+    re_lambda = 100  # Reynolds number
+    ao = 11  # Normalized acceleration variance
+
+    expected = kolmogorov_time * np.sqrt((2 * re_lambda) / (15**0.5 * ao))
+    result = get_lagrangian_taylor_microscale_time(
+        kolmogorov_time, re_lambda, ao
+    )
+
+    assert np.isclose(result, expected, atol=1e-10)
+
+
+def test_get_lagrangian_taylor_microscale_time_array():
+    """
+    Test get_lagrangian_taylor_microscale_time with NumPy array inputs.
+    """
+    kolmogorov_time = np.array([0.01, 0.02])
+    re_lambda = np.array([100, 200])
+    ao = np.array([11, 12])
+
+    expected = kolmogorov_time * np.sqrt((2 * re_lambda) / (15**0.5 * ao))
+    result = get_lagrangian_taylor_microscale_time(
+        kolmogorov_time, re_lambda, ao
+    )
+
+    assert np.allclose(result, expected, atol=1e-10)
+
+
+def test_get_lagrangian_taylor_microscale_time_invalid():
+    """
+    Test that get_lagrangian_taylor_microscale_time raises errors for invalid
+    inputs.
+    """
+    with pytest.raises(ValueError):
+        get_lagrangian_taylor_microscale_time(-0.01, 100, 11)
+
+    with pytest.raises(ValueError):
+        get_lagrangian_taylor_microscale_time(0.01, -100, 11)
+
+    with pytest.raises(ValueError):
+        get_lagrangian_taylor_microscale_time(0.01, 100, -11)
+
+
+def test_get_taylor_microscale_scalar():
+    """
+    Test get_taylor_microscale with scalar inputs.
+    """
+    rms_velocity = 0.5  # m/s
+    kinematic_viscosity = 1.5e-5  # m²/s
+    turbulent_dissipation = 1e-3  # m²/s³
+
+    expected = rms_velocity * np.sqrt(
+        (15 * kinematic_viscosity**2) / turbulent_dissipation
+    )
+    result = get_taylor_microscale(
+        rms_velocity, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.isclose(result, expected, atol=1e-10)
+
+
+def test_get_taylor_microscale_array():
+    """
+    Test get_taylor_microscale with NumPy array inputs.
+    """
+    rms_velocity = np.array([0.5, 0.8])
+    kinematic_viscosity = np.array([1.5e-5, 1.2e-5])
+    turbulent_dissipation = np.array([1e-3, 2e-3])
+
+    expected = rms_velocity * np.sqrt(
+        (15 * kinematic_viscosity**2) / turbulent_dissipation
+    )
+    result = get_taylor_microscale(
+        rms_velocity, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.allclose(result, expected, atol=1e-10)
+
+
+def test_get_taylor_microscale_invalid():
+    """
+    Test that get_taylor_microscale raises errors for invalid inputs.
+    """
+    with pytest.raises(ValueError):
+        get_taylor_microscale(-0.5, 1.5e-5, 1e-3)
+
+    with pytest.raises(ValueError):
+        get_taylor_microscale(0.5, -1.5e-5, 1e-3)
+
+    with pytest.raises(ValueError):
+        get_taylor_microscale(0.5, 1.5e-5, -1e-3)
+
+
+def test_taylor_scales_edge_case():
+    """
+    Test both Taylor scale functions with very small values near machine
+    precision.
+    """
+    kolmogorov_time = 1e-10
+    re_lambda = 1.0
+    ao = 1.0
+
+    expected_tt = kolmogorov_time * np.sqrt((2 * re_lambda) / (15**0.5 * ao))
+    result_tt = get_lagrangian_taylor_microscale_time(
+        kolmogorov_time, re_lambda, ao
+    )
+
+    assert np.isclose(result_tt, expected_tt, atol=1e-10)
+
+    rms_velocity = 1e-10
+    kinematic_viscosity = 1e-10
+    turbulent_dissipation = 1e-10
+
+    expected_lambda = rms_velocity * np.sqrt(
+        (15 * kinematic_viscosity**2) / turbulent_dissipation
+    )
+    result_lambda = get_taylor_microscale(
+        rms_velocity, kinematic_viscosity, turbulent_dissipation
+    )
+
+    assert np.isclose(result_lambda, expected_lambda, atol=1e-10)