naturedynamics 1.1__tar.gz

naturedynamics-1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shaikh Umer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

naturedynamics-1.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: naturedynamics
+Version: 1.1
+Summary: A comprehensive physics library providing constants, equations, and formulas
+Author-email: Fabian Schober <reach@fabianschober.com>
+License: MIT
+Project-URL: Homepage, https://github.com/schobernoise/naturedynamics
+Project-URL: Repository, https://github.com/schobernoise/naturedynamics
+Project-URL: Issues, https://github.com/schobernoise/naturedynamics/issues
+Keywords: physics,science,constants,equations,mechanics,quantum
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: mypy>=0.812; extra == "dev"
+Requires-Dist: build>=0.7; extra == "dev"
+Requires-Dist: twine>=3.4; extra == "dev"
+Requires-Dist: wheel>=0.36; extra == "dev"
+Dynamic: license-file
+
+# naturedynamics — A Comprehensive Physics Library in Python
+
+**naturedynamics** is a Python library that offers an extensive collection of physical constants, equations, and formulas. It is a fork of https://github.com/reumer06/fphysics. @reumer06 did an amazing job in compiling an exhaustive collection of laws and formulas. This was exactly what I envisioned too, so I am very grateful to build on that and extend it in all kind of directions. 
+
+## Key Features
+
+### Constants Database
+Includes essential physical constants — SI base units, quantum constants, astronomical parameters, and more.
+
+### Modular Formula Collections
+Separate modules for mechanics, thermodynamics, electromagnetism, atomic physics, nuclear physics, relativity, statistical mechanics, and beyond.
+
+### Unit Conversion 
+Convert seamlessly between SI, CGS, and natural units.
+
+### Built for Learning and Worldbuilding
+Perfect for integration into scientific calculators, simulations and teaching aids.
+
+
+
+## Quick Start
+```python
+import naturedynamics as nd
+from naturedynamics.relativity.general import schwarzschild_radius
+from naturedynamics.thermodynamics.heat_engines import carnot_efficiency
+
+# Access fundamental constants
+print(nd.constants.SPEED_OF_LIGHT)   
+
+# Calculate Schwarzschild radius
+print(schwarzschild_radius(10))
+
+#Calulate the Carnot Efficiency
+print(carnot_efficiency(500, 300))
+```
+
+## Contributing
+
+I welcome all contributions — from adding new formulas to refining documentation.
+
+1. **Fork** the repository
+2. **Create** a feature branch
+3. **Submit** a pull request
+4. **Report** issues or suggest enhancements
+
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

naturedynamics-1.1/README.md

@@ -0,0 +1,49 @@
+# naturedynamics — A Comprehensive Physics Library in Python
+
+**naturedynamics** is a Python library that offers an extensive collection of physical constants, equations, and formulas. It is a fork of https://github.com/reumer06/fphysics. @reumer06 did an amazing job in compiling an exhaustive collection of laws and formulas. This was exactly what I envisioned too, so I am very grateful to build on that and extend it in all kind of directions. 
+
+## Key Features
+
+### Constants Database
+Includes essential physical constants — SI base units, quantum constants, astronomical parameters, and more.
+
+### Modular Formula Collections
+Separate modules for mechanics, thermodynamics, electromagnetism, atomic physics, nuclear physics, relativity, statistical mechanics, and beyond.
+
+### Unit Conversion 
+Convert seamlessly between SI, CGS, and natural units.
+
+### Built for Learning and Worldbuilding
+Perfect for integration into scientific calculators, simulations and teaching aids.
+
+
+
+## Quick Start
+```python
+import naturedynamics as nd
+from naturedynamics.relativity.general import schwarzschild_radius
+from naturedynamics.thermodynamics.heat_engines import carnot_efficiency
+
+# Access fundamental constants
+print(nd.constants.SPEED_OF_LIGHT)   
+
+# Calculate Schwarzschild radius
+print(schwarzschild_radius(10))
+
+#Calulate the Carnot Efficiency
+print(carnot_efficiency(500, 300))
+```
+
+## Contributing
+
+I welcome all contributions — from adding new formulas to refining documentation.
+
+1. **Fork** the repository
+2. **Create** a feature branch
+3. **Submit** a pull request
+4. **Report** issues or suggest enhancements
+
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

naturedynamics-1.1/naturedynamics/__init__.py

@@ -0,0 +1,5 @@
+"""naturedynamics: a comprehensive physics library of constants, equations, and formulas."""
+
+from . import constants
+
+__version__ = "1.1"

naturedynamics-1.1/naturedynamics/applications/energy.py

@@ -0,0 +1,124 @@
+import math
+from ..constants import *
+
+def solar_cell_efficiency(power_out, solar_irradiance, cell_area):
+    """Solar cell efficiency"""
+    power_in = solar_irradiance * cell_area
+    return power_out / power_in
+
+def photovoltaic_current(photon_flux, quantum_efficiency, charge=ELEMENTARY_CHARGE):
+    """Photovoltaic current calculation"""
+    return photon_flux * quantum_efficiency * charge
+
+def carnot_efficiency(hot_temp, cold_temp):
+    """Carnot cycle efficiency"""
+    return 1 - cold_temp / hot_temp
+
+def wind_power(air_density, swept_area, wind_speed, power_coefficient=0.4):
+    """Wind turbine power output"""
+    return 0.5 * air_density * swept_area * wind_speed**3 * power_coefficient
+
+def hydroelectric_power(flow_rate, head, efficiency=0.9):
+    """Hydroelectric power calculation"""
+    return flow_rate * WATER_DENSITY * EARTH_GRAVITY * head * efficiency
+
+def fuel_cell_voltage(gibbs_free_energy, electrons_transferred=2):
+    """Fuel cell theoretical voltage"""
+    return -gibbs_free_energy / (electrons_transferred * ELEMENTARY_CHARGE)
+
+def battery_energy_density(voltage, capacity, mass):
+    """Battery energy density"""
+    energy = voltage * capacity * 3600
+    return energy / mass
+
+def thermal_conductivity_insulation(heat_flux, thickness, temperature_diff):
+    """Thermal conductivity from insulation performance"""
+    return heat_flux * thickness / temperature_diff
+
+def heat_pump_cop(heat_delivered, work_input):
+    """Heat pump coefficient of performance"""
+    return heat_delivered / work_input
+
+def stirling_engine_power(pressure_amplitude, volume_amplitude, frequency):
+    """Stirling engine power approximation"""
+    return pressure_amplitude * volume_amplitude * frequency
+
+def nuclear_binding_energy(mass_number, binding_energy_per_nucleon=8.5):
+    """Nuclear binding energy"""
+    return mass_number * binding_energy_per_nucleon * ELECTRON_VOLT * 1e6
+
+def fission_energy_release(fissile_mass):
+    """Energy released in nuclear fission"""
+    energy_per_fission = 200e6 * ELECTRON_VOLT
+    nuclei_per_gram = AVOGADRO_NUMBER / 235
+    return fissile_mass * nuclei_per_gram * energy_per_fission
+
+def fusion_energy_release(fuel_mass, q_value=17.6e6):
+    """Energy released in nuclear fusion"""
+    return fuel_mass * q_value * ELECTRON_VOLT / (4 * ATOMIC_MASS_UNIT)
+
+def blackbody_power_density(temperature):
+    """Blackbody power density"""
+    return STEFAN_BOLTZMANN_CONSTANT * temperature**4
+
+def wien_peak_wavelength(temperature):
+    """Wien's displacement law"""
+    return WIEN_DISPLACEMENT_CONSTANT / temperature
+
+def photon_energy(wavelength):
+    """Photon energy from wavelength"""
+    return PLANCK_CONSTANT * SPEED_OF_LIGHT / wavelength
+
+def solar_constant_distance(distance_au=1.0):
+    """Solar constant at given distance"""
+    return SOLAR_LUMINOSITY / (4 * PI * (distance_au * ASTRONOMICAL_UNIT)**2)
+
+def geothermal_gradient_power(gradient, area, thermal_conductivity):
+    """Geothermal power from temperature gradient"""
+    return gradient * area * thermal_conductivity
+
+def piezoelectric_power(force, displacement, coupling_coefficient):
+    """Piezoelectric power generation"""
+    return force * displacement * coupling_coefficient
+
+def thermoelectric_power(seebeck_coeff, temperature_diff, resistance):
+    """Thermoelectric power generation"""
+    voltage = seebeck_coeff * temperature_diff
+    return voltage**2 / resistance
+
+def biomass_energy_content(mass, heating_value=15e6):
+    """Biomass energy content"""
+    return mass * heating_value
+
+def tidal_power(tidal_range, basin_area, water_density=1025):
+    """Tidal energy potential"""
+    return 0.5 * water_density * EARTH_GRAVITY * basin_area * tidal_range**2
+
+def wave_power(wave_height, wave_period, water_depth):
+    """Ocean wave power per unit width"""
+    wavelength = EARTH_GRAVITY * wave_period**2 / (2 * PI)
+    group_velocity = math.sqrt(EARTH_GRAVITY * wavelength / (2 * PI)) / 2
+    return (WATER_DENSITY * EARTH_GRAVITY * wave_height**2 * group_velocity) / 8
+
+def energy_storage_time(capacity, power_rating):
+    """Energy storage duration"""
+    return capacity / power_rating
+
+def round_trip_efficiency(energy_out, energy_in):
+    """Energy storage round-trip efficiency"""
+    return energy_out / energy_in
+
+def grid_frequency_regulation(power_imbalance, system_inertia):
+    """Grid frequency change from power imbalance"""
+    return power_imbalance / system_inertia
+
+def transmission_line_losses(resistance, current):
+    """Transmission line power losses"""
+    return resistance * current**2
+
+def transformer_efficiency(primary_voltage, primary_current, secondary_voltage, secondary_current):
+    """Transformer efficiency"""
+    power_in = primary_voltage * primary_current
+    power_out = secondary_voltage * secondary_current
+    return power_out / power_in
+

naturedynamics-1.1/naturedynamics/applications/engineering.py

@@ -0,0 +1,100 @@
+import math
+from ..constants import *
+
+def stress(force, area):
+    """Calculate stress"""
+    return force / area
+
+def strain(delta_length, original_length):
+    """Calculate strain"""
+    return delta_length / original_length
+
+def young_modulus(stress, strain):
+    """Calculate Young's modulus"""
+    return stress / strain
+
+def thermal_expansion(length, alpha, delta_temp):
+    """Linear thermal expansion"""
+    return length * alpha * delta_temp
+
+def heat_transfer_conduction(k, area, delta_temp, thickness):
+    """Heat transfer by conduction"""
+    return k * area * delta_temp / thickness
+
+def reynolds_number(density, velocity, length, viscosity):
+    """Calculate Reynolds number"""
+    return density * velocity * length / viscosity
+
+def drag_force(drag_coeff, density, velocity, area):
+    """Calculate drag force"""
+    return 0.5 * drag_coeff * density * velocity**2 * area
+
+def lift_force(lift_coeff, density, velocity, area):
+    """Calculate lift force"""
+    return 0.5 * lift_coeff * density * velocity**2 * area
+
+def moment_of_inertia_rectangle(width, height):
+    """Moment of inertia for rectangular cross-section"""
+    return width * height**3 / 12
+
+def critical_buckling_load(e_modulus, moment_inertia, length):
+    """Euler critical buckling load"""
+    return PI**2 * e_modulus * moment_inertia / length**2
+
+def fatigue_life(stress_amplitude, fatigue_strength_coeff, fatigue_strength_exp):
+    """S-N fatigue life estimation"""
+    return (stress_amplitude / fatigue_strength_coeff)**(1/fatigue_strength_exp)
+
+def shear_stress_circular(torque, radius, polar_moment):
+    """Shear stress in circular shaft"""
+    return torque * radius / polar_moment
+
+def deflection_cantilever(force, length, e_modulus, moment_inertia):
+    """Deflection of cantilever beam"""
+    return force * length**3 / (3 * e_modulus * moment_inertia)
+
+def natural_frequency_beam(e_modulus, moment_inertia, mass_per_length, length):
+    """Natural frequency of beam"""
+    return (1.875**2 / (2 * PI)) * math.sqrt(e_modulus * moment_inertia / (mass_per_length * length**4))
+
+def thermal_stress(e_modulus, alpha, delta_temp):
+    """Thermal stress in constrained material"""
+    return e_modulus * alpha * delta_temp
+
+def pressure_vessel_hoop_stress(pressure, radius, thickness):
+    """Hoop stress in thin-walled pressure vessel"""
+    return pressure * radius / thickness
+
+def creep_rate(stress, temperature, activation_energy, stress_exponent=5):
+    """Creep rate equation"""
+    return stress**stress_exponent * math.exp(-activation_energy / (BOLTZMANN_CONSTANT * temperature))
+
+def fracture_toughness_critical_length(k_ic, stress, shape_factor=1):
+    """Critical crack length from fracture toughness"""
+    return (k_ic / (shape_factor * stress))**2 / PI
+
+def electrical_resistance(resistivity, length, area):
+    """Electrical resistance"""
+    return resistivity * length / area
+
+def power_dissipation(current, resistance):
+    """Power dissipation in resistor"""
+    return current**2 * resistance
+
+def capacitance_parallel_plate(permittivity, area, distance):
+    """Capacitance of parallel plate capacitor"""
+    return permittivity * area / distance
+
+def inductance_solenoid(permeability, turns, area, length):
+    """Inductance of solenoid"""
+    return permeability * turns**2 * area / length
+
+def skin_depth(frequency, conductivity, permeability):
+    """Electromagnetic skin depth"""
+    return math.sqrt(2 / (2 * PI * frequency * conductivity * permeability))
+
+def doppler_shift(source_freq, source_velocity, observer_velocity, wave_speed):
+    """Doppler frequency shift"""
+    return source_freq * (wave_speed + observer_velocity) / (wave_speed - source_velocity)
+
+

naturedynamics-1.1/naturedynamics/applications/environmental.py

@@ -0,0 +1,111 @@
+import math
+from ..constants import *
+
+def atmospheric_pressure_altitude(altitude):
+    """Atmospheric pressure at altitude"""
+    return ATMOSPHERIC_PRESSURE * math.exp(-altitude / 8400)
+
+def air_density_altitude(altitude, temperature=288.15):
+    """Air density at altitude"""
+    pressure = atmospheric_pressure_altitude(altitude)
+    return pressure / (287 * temperature)
+
+def sound_speed_air(temperature):
+    """Speed of sound in air at given temperature"""
+    return 331.3 * math.sqrt(temperature / 273.15)
+
+def greenhouse_effect_temperature(solar_constant, albedo, emissivity=1.0):
+    """Greenhouse effect temperature calculation"""
+    absorbed_power = solar_constant * (1 - albedo) / 4
+    return (absorbed_power / (emissivity * STEFAN_BOLTZMANN_CONSTANT))**(1/4)
+
+def solar_irradiance(solar_constant, zenith_angle):
+    """Solar irradiance at surface"""
+    return solar_constant * math.cos(zenith_angle)
+
+def photosynthetic_photon_flux(irradiance, wavelength=550e-9):
+    """Photosynthetic photon flux density"""
+    photon_energy = PLANCK_CONSTANT * SPEED_OF_LIGHT / wavelength
+    return irradiance / photon_energy
+
+def clausius_clapeyron(temperature, latent_heat):
+    """Clausius-Clapeyron equation for vapor pressure"""
+    reference_temp = 273.15
+    reference_pressure = 611.2
+    return reference_pressure * math.exp((latent_heat / GAS_CONSTANT) * (1/reference_temp - 1/temperature))
+
+def mixing_ratio(vapor_pressure, total_pressure):
+    """Water vapor mixing ratio"""
+    return 0.622 * vapor_pressure / (total_pressure - vapor_pressure)
+
+def potential_temperature(temperature, pressure, reference_pressure=100000):
+    """Potential temperature"""
+    return temperature * (reference_pressure / pressure)**(0.286)
+
+def richardson_number(gravity, temperature_gradient, wind_shear, reference_temp):
+    """Richardson number for atmospheric stability"""
+    return (gravity / reference_temp) * temperature_gradient / wind_shear**2
+
+def coriolis_parameter(latitude):
+    """Coriolis parameter"""
+    omega = 2 * PI / 86400
+    return 2 * omega * math.sin(math.radians(latitude))
+
+def geostrophic_wind(pressure_gradient, density, latitude):
+    """Geostrophic wind speed"""
+    f = coriolis_parameter(latitude)
+    return pressure_gradient / (density * f)
+
+def ozone_depletion_potential(concentration, reaction_rate, lifetime):
+    """Ozone depletion potential"""
+    return concentration * reaction_rate * lifetime
+
+def radiative_forcing(delta_concentration, forcing_efficiency):
+    """Radiative forcing calculation"""
+    return forcing_efficiency * math.log(delta_concentration)
+
+def heat_island_intensity(urban_temp, rural_temp):
+    """Urban heat island intensity"""
+    return urban_temp - rural_temp
+
+def albedo_feedback(initial_albedo, temperature_change, feedback_coefficient):
+    """Albedo feedback mechanism"""
+    return initial_albedo - feedback_coefficient * temperature_change
+
+def photolysis_rate(solar_zenith, absorption_cross_section, quantum_yield):
+    """Photolysis rate calculation"""
+    actinic_flux = 1e15 * math.cos(solar_zenith)
+    return absorption_cross_section * quantum_yield * actinic_flux
+
+def aerosol_optical_depth(extinction_coeff, path_length):
+    """Aerosol optical depth"""
+    return extinction_coeff * path_length
+
+def scattering_coefficient(particle_concentration, scattering_cross_section):
+    """Aerosol scattering coefficient"""
+    return particle_concentration * scattering_cross_section
+
+def visibility_range(extinction_coeff, contrast_threshold=0.02):
+    """Visibility range from extinction"""
+    return -math.log(contrast_threshold) / extinction_coeff
+
+def settling_velocity(particle_diameter, particle_density, air_density=1.2, viscosity=1.8e-5):
+    """Particle settling velocity"""
+    return (particle_diameter**2 * (particle_density - air_density) * EARTH_GRAVITY) / (18 * viscosity)
+
+def diffusion_coefficient_atmospheric(temperature, pressure, molecular_weight):
+    """Atmospheric diffusion coefficient"""
+    return 1e-5 * (temperature / 273.15)**(1.75) * (101325 / pressure) * (29 / molecular_weight)**0.5
+
+def residence_time(total_mass, removal_rate):
+    """Atmospheric residence time"""
+    return total_mass / removal_rate
+
+def carbon_cycle_flux(concentration_gradient, transfer_velocity):
+    """Carbon cycle flux calculation"""
+    return concentration_gradient * transfer_velocity
+
+def photochemical_equilibrium(production_rate, loss_rate):
+    """Photochemical equilibrium concentration"""
+    return production_rate / loss_rate
+

naturedynamics-1.1/naturedynamics/applications/medical.py

@@ -0,0 +1,70 @@
+import math
+from ..constants import *
+
+def radiation_dose_rate(activity, distance, gamma_constant=0.5):
+    """Calculate radiation dose rate"""
+    return gamma_constant * activity / (distance ** 2)
+
+def half_value_layer(attenuation_coeff):
+    """Calculate half-value layer thickness"""
+    return math.log(2) / attenuation_coeff
+
+def ct_number(mu_tissue, mu_water):
+    """Calculate CT Hounsfield number"""
+    return 1000 * (mu_tissue - mu_water) / mu_water
+
+def mri_relaxation(t, t1):
+    """MRI T1 relaxation recovery"""
+    return 1 - math.exp(-t / t1)
+
+def ultrasound_intensity(power, beam_area):
+    """Calculate ultrasound intensity"""
+    return power / beam_area
+
+def radioactive_decay(n0, decay_constant, time):
+    """Radioactive decay law"""
+    return n0 * math.exp(-decay_constant * time)
+
+def linear_energy_transfer(energy_loss, path_length):
+    """Calculate linear energy transfer (LET)"""
+    return energy_loss / path_length
+
+def relative_biological_effectiveness(dose_test, dose_reference):
+    """Calculate relative biological effectiveness (RBE)"""
+    return dose_reference / dose_test
+
+def bragg_peak_range(energy, density=1.0, z_eff=7.4):
+    """Approximate Bragg peak range for protons"""
+    return 0.31 * (energy ** 1.8) / (density * z_eff)
+
+def compton_scatter_energy(incident_energy, scatter_angle):
+    """Compton scattered photon energy"""
+    electron_rest_energy = ELECTRON_MASS * SPEED_OF_LIGHT**2 / ELECTRON_VOLT
+    denominator = 1 + (incident_energy / electron_rest_energy) * (1 - math.cos(scatter_angle))
+    return incident_energy / denominator
+
+def tissue_air_ratio(depth, field_size, energy):
+    """Simplified tissue-air ratio calculation"""
+    mu = 0.05 * energy**(-0.5)
+    return math.exp(-mu * depth) * (1 + 0.1 * field_size)
+
+def percent_depth_dose(depth, ssd=100, field_size=10, energy=6):
+    """Percent depth dose calculation"""
+    dmax = 0.9 + 0.15 * energy
+    if depth <= dmax:
+        return 100
+    return 100 * math.exp(-0.05 * (depth - dmax))
+
+def monitor_unit_calculation(prescribed_dose, dose_rate, field_factors=1.0):
+    """Calculate monitor units for treatment"""
+    return prescribed_dose / (dose_rate * field_factors)
+
+def biological_effective_dose(physical_dose, alpha_beta_ratio, dose_per_fraction):
+    """Calculate biological effective dose"""
+    return physical_dose * (1 + dose_per_fraction / alpha_beta_ratio)
+
+def effective_dose(absorbed_dose, radiation_weighting, tissue_weighting):
+    """Calculate effective dose"""
+    equivalent_dose = absorbed_dose * radiation_weighting
+    return equivalent_dose * tissue_weighting
+

naturedynamics-1.1/naturedynamics/astrophysics/atmospheric.py

@@ -0,0 +1,77 @@
+import math
+from ..constants import *
+
+
+def column_number_density(pressure, gravity, molar_mass):
+    """Molecules per m^2 in a hydrostatic column: P/(g*m_molecule).
+
+    Args: surface pressure (Pa), gravity (m/s^2), mean molar mass (kg/mol).
+    """
+    molecule_mass = molar_mass / AVOGADRO_NUMBER
+    return pressure / (gravity * molecule_mass)
+
+
+def rayleigh_cross_section(wavelength_nm, refractivity, king_factor=1.0):
+    """Rayleigh scattering cross-section (m^2) per molecule at a wavelength.
+
+    refractivity is (n - 1) at STP; king_factor corrects for molecular
+    anisotropy. Scales as 1/lambda^4, which is why skies are blue.
+    """
+    lam = wavelength_nm * 1e-9
+    n = 1.0 + refractivity
+    factor = ((n**2 - 1.0) / (n**2 + 2.0)) ** 2
+    return (
+        24.0
+        * math.pi**3
+        / (lam**4 * LOSCHMIDT_NUMBER**2)
+        * factor
+        * king_factor
+    )
+
+
+def rayleigh_optical_depth(wavelength_nm, refractivity, king_factor, column_density):
+    """Dimensionless Rayleigh optical depth through a molecular column."""
+    cross_section = rayleigh_cross_section(wavelength_nm, refractivity, king_factor)
+    return cross_section * column_density
+
+
+def beer_lambert_transmission(optical_depth, air_mass=1.0):
+    """Fraction of a beam surviving a slab: exp(-tau/mu_0).
+
+    air_mass is 1/cos(solar zenith angle); 1.0 is the overhead sun.
+    """
+    return math.exp(-optical_depth / air_mass)
+
+
+def single_scatter_fraction(optical_depth, air_mass=1.0):
+    """Fraction of a beam scattered out of it along a path: 1 - T.
+
+    The single-scattering approximation: a photon that leaves the direct
+    beam is counted as entering the diffuse field exactly once, and nothing
+    scatters back out again. Spectrally this is what makes a sky blue --
+    the Rayleigh cross-section goes as lambda^-4, so short wavelengths are
+    removed from the beam and appear overhead instead.
+
+    It holds while the optical depth is small: Earth's zenith Rayleigh
+    depth is about 0.1 at 550 nm. For a thick atmosphere it overstates the
+    diffuse field, because multiple scattering redistributes light and,
+    with absorption present, removes some of it entirely.
+
+    Args: optical depth (dimensionless), air mass (1/cos of the zenith
+    angle; 1.0 looks straight up).
+    """
+    return 1.0 - beer_lambert_transmission(optical_depth, air_mass)
+
+
+def mixture_refractivity(composition, refractivity_table):
+    """Mole-fraction-weighted refractivity of a gas mixture.
+
+    composition maps species key -> percentage; refractivity is additive.
+    """
+    total = sum(composition.values())
+    if total <= 0:
+        return 0.0
+    return sum(
+        percent / total * refractivity_table[species]
+        for species, percent in composition.items()
+    )