Skip to content

particula.particles.properties.diffusive_knudsen_module

diffusive_knudsen_module

Module for the diffusive knudsen number.

get_diffusive_knudsen_number 

get_diffusive_knudsen_number(particle_radius: Union[float, NDArray[float64]], particle_mass: Union[float, NDArray[float64]], friction_factor: Union[float, NDArray[float64]], coulomb_potential_ratio: Union[float, NDArray[float64]] = 0.0, temperature: float = 298.15) -> Union[float, NDArray[np.float64]]

Compute the diffusive Knudsen number for particle-particle interactions.

The diffusive Knudsen number (Kn_d) differs from the standard Knudsen number. It represents the ratio of the mean particle persistence distance to the effective Coulombic interaction scale. Mathematically:

  • Kn_d = [ √(k_B × T × μ_red) / f_red ] / [ (rᵢ + rⱼ) × (Γ_c / Γ_k) ]
    • k_B is the Boltzmann constant (J/K).
    • T is the temperature (K).
    • μ_red is the reduced mass of particles (kg).
    • f_red is the reduced friction factor (dimensionless).
    • rᵢ + rⱼ is the sum of radii for the interacting particles (m).
    • Γ_c is the continuum-limit Coulomb enhancement factor(dimensionless).
    • Γ_k is the kinetic-limit Coulomb enhancement factor (dimensionless).

Parameters:

  • - particle_radius –

    Radius of the particle(s) in meters (m).

  • - particle_mass –

    Mass of the particle(s) in kilograms (kg).

  • - friction_factor –

    Friction factor(s) (dimensionless).

  • - coulomb_potential_ratio –

    Coulomb potential ratio (dimensionless), zero if no charge.

  • - temperature –

    Temperature of the system in Kelvin (K).

Returns:

  • Union[float, NDArray[float64]] –
    • The diffusive Knudsen number, either a float or NDArray[np.float64].

Examples:

Single Particle Example
import numpy as np
import particula as par
par.particles.get_diffusive_knudsen_number(
    particle_radius=1e-7,
    particle_mass=1e-17,
    friction_factor=0.8,
    coulomb_potential_ratio=0.3,
    temperature=300
)
# Output: 0.12...
Multiple Particles Example
import numpy as np
import particula as par
# Multiple particles example
radius_arr = np.array([1e-7, 2e-7])
mass_arr = np.array([1e-17, 2e-17])
friction_arr = np.array([0.8, 1.1])
potential_arr = np.array([0.3, 0.5])
par.particles.par.get_diffusive_knudsen_number(
    radius_arr, mass_arr, friction_arr, potential_arr
)
# Output: array([...])

References
  • Chahl, H. S., & Gopalakrishnan, R. (2019). "High potential, near free molecular regime Coulombic collisions in aerosols and dusty plasmas." Aerosol Science and Technology, 53(8), 933-957. https://doi.org/10.1080/02786826.2019.1614522
  • Gopalakrishnan, R., & Hogan, C. J. (2012). "Coulomb-influenced collisions in aerosols and dusty plasmas." Physical Review E, 85(2). https://doi.org/10.1103/PhysRevE.85.026410
Source code in particula/particles/properties/diffusive_knudsen_module.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
@validate_inputs(
    {
        "particle_radius": "nonnegative",
        "particle_mass": "nonnegative",
        "friction_factor": "nonnegative",
    }
)
def get_diffusive_knudsen_number(
    particle_radius: Union[float, NDArray[np.float64]],
    particle_mass: Union[float, NDArray[np.float64]],
    friction_factor: Union[float, NDArray[np.float64]],
    coulomb_potential_ratio: Union[float, NDArray[np.float64]] = 0.0,
    temperature: float = 298.15,
) -> Union[float, NDArray[np.float64]]:
    """Compute the diffusive Knudsen number for particle-particle interactions.

    The *diffusive* Knudsen number (Kn_d) differs from the standard Knudsen
    number. It represents the ratio of the mean particle persistence
    distance to the effective Coulombic interaction scale. Mathematically:

    - Kn_d = [ √(k_B × T × μ_red) / f_red ] / [ (rᵢ + rⱼ) × (Γ_c / Γ_k) ]
        - k_B is the Boltzmann constant (J/K).
        - T is the temperature (K).
        - μ_red is the reduced mass of particles (kg).
        - f_red is the reduced friction factor (dimensionless).
        - rᵢ + rⱼ is the sum of radii for the interacting particles (m).
        - Γ_c is the continuum-limit Coulomb enhancement factor(dimensionless).
        - Γ_k is the kinetic-limit Coulomb enhancement factor (dimensionless).

    Arguments:
        - particle_radius : Radius of the particle(s) in meters (m).
        - particle_mass : Mass of the particle(s) in kilograms (kg).
        - friction_factor : Friction factor(s) (dimensionless).
        - coulomb_potential_ratio : Coulomb potential ratio (dimensionless),
          zero if no charge.
        - temperature : Temperature of the system in Kelvin (K).

    Returns:
        - The diffusive Knudsen number, either a float or NDArray[np.float64].

    Examples:
        ```py title="Single Particle Example"
        import numpy as np
        import particula as par
        par.particles.get_diffusive_knudsen_number(
            particle_radius=1e-7,
            particle_mass=1e-17,
            friction_factor=0.8,
            coulomb_potential_ratio=0.3,
            temperature=300
        )
        # Output: 0.12...
        ```
        ```py title="Multiple Particles Example"
        import numpy as np
        import particula as par
        # Multiple particles example
        radius_arr = np.array([1e-7, 2e-7])
        mass_arr = np.array([1e-17, 2e-17])
        friction_arr = np.array([0.8, 1.1])
        potential_arr = np.array([0.3, 0.5])
        par.particles.par.get_diffusive_knudsen_number(
            radius_arr, mass_arr, friction_arr, potential_arr
        )
        # Output: array([...])
        ```

    References:
        - Chahl, H. S., & Gopalakrishnan, R. (2019). "High potential, near free
          molecular regime Coulombic collisions in aerosols and dusty plasmas."
          Aerosol Science and Technology, 53(8), 933-957.
          https://doi.org/10.1080/02786826.2019.1614522
        - Gopalakrishnan, R., & Hogan, C. J. (2012). "Coulomb-influenced
          collisions in aerosols and dusty plasmas." Physical Review E, 85(2).
          https://doi.org/10.1103/PhysRevE.85.026410
    """
    # Calculate the pairwise sum of radii
    sum_of_radii: Union[float, NDArray[np.float64]]
    if isinstance(particle_radius, np.ndarray):
        sum_of_radii = particle_radius[:, np.newaxis] + particle_radius
    else:
        sum_of_radii = 2.0 * particle_radius

    # Calculate reduced mass
    reduced_mass: Union[float, NDArray[np.float64]]
    if isinstance(particle_mass, np.ndarray):
        reduced_mass = get_reduced_self_broadcast(particle_mass)
    else:
        reduced_mass = 0.5 * particle_mass

    # Calculate reduced friction factor
    reduced_friction_factor: Union[float, NDArray[np.float64]]
    if isinstance(friction_factor, np.ndarray):
        reduced_friction_factor = get_reduced_self_broadcast(friction_factor)
    else:
        reduced_friction_factor = 0.5 * friction_factor

    # Calculate the kinetic and continuum enhancements
    kinetic_enhance = coulomb_enhancement.get_coulomb_kinetic_limit(
        coulomb_potential_ratio
    )
    continuum_enhance = coulomb_enhancement.get_coulomb_continuum_limit(
        coulomb_potential_ratio
    )

    # Final calculation of diffusive Knudsen number
    numerator = (
        np.sqrt(temperature * BOLTZMANN_CONSTANT * reduced_mass)
        / reduced_friction_factor
    )
    # Guard for same-sign repulsion; see coulomb_enhancement.py:83-97 and
    # diffusive_knudsen_module.py:113-119 (issue #1087).
    denominator = np.divide(
        sum_of_radii * continuum_enhance,
        kinetic_enhance,
        out=np.full_like(sum_of_radii, np.inf, dtype=np.float64),
        where=kinetic_enhance >= KINETIC_ENHANCE_MIN,
    )

    return numerator / denominator