Constants

class Constant:
    """
    Physical or astronomical constant with units and uncertainty.
    
    Parameters:
    - abbrev: constant abbreviation
    - name: full constant name
    - value: numerical value
    - unit: astropy unit
    - uncertainty: uncertainty in the value
    - reference: literature reference
    - system: constant system (e.g., 'codata2018')
    """
    def __init__(self, abbrev, name, value, unit, uncertainty, reference=None, system=None): ...
    
    @property
    def value(self):
        """Numerical value of constant."""
    
    @property
    def unit(self):
        """Unit of constant."""
    
    @property
    def uncertainty(self):
        """Uncertainty in constant value."""
    
    @property
    def name(self):
        """Full name of constant."""
    
    @property
    def abbrev(self):
        """Abbreviation for constant."""
    
    @property
    def reference(self):
        """Literature reference."""
    
    def __float__(self):
        """Convert to float value."""
    
    def __array__(self):
        """Convert to numpy array."""

class EMConstant(Constant):
    """
    Electromagnetic constant with system-dependent values.
    
    Handles constants that have different values in different unit systems
    (e.g., CGS-ESU vs CGS-Gaussian vs SI).
    """
    def __init__(self, abbrev, name, value, unit, uncertainty, reference=None, system=None): ...

# Import physical constants
from astropy.constants import c, h, hbar, k_B, sigma_sb, a0, m_e, m_p, m_n, u, G, e, eps0, mu0, alpha, R, N_A

# Speed of light
c: Constant  # 299792458.0 m / s

# Planck constants
h: Constant      # 6.62607015e-34 J s (Planck constant)
hbar: Constant   # 1.0545718176e-34 J s (reduced Planck constant)

# Boltzmann constant
k_B: Constant    # 1.380649e-23 J / K

# Stefan-Boltzmann constant  
sigma_sb: Constant  # 5.670374419e-08 W / (K4 m2)

# Bohr radius
a0: Constant     # 5.29177210903e-11 m

# Particle masses
m_e: Constant    # 9.1093837015e-31 kg (electron mass)
m_p: Constant    # 1.67262192369e-27 kg (proton mass)  
m_n: Constant    # 1.67492749804e-27 kg (neutron mass)
u: Constant      # 1.66053906660e-27 kg (atomic mass unit)

# Gravitational constant
G: Constant      # 6.67430e-11 m3 / (kg s2)

# Elementary charge
e: Constant      # 1.602176634e-19 C

# Electric permittivity and permeability
eps0: Constant   # 8.8541878128e-12 F / m (vacuum permittivity)
mu0: Constant    # 1.25663706212e-06 H / m (vacuum permeability)

# Fine structure constant
alpha: Constant  # 0.0072973525693 (dimensionless)

# Gas constant
R: Constant      # 8.314462618 J / (K mol)

# Avogadro constant
N_A: Constant    # 6.02214076e23 1 / mol

# Import astronomical constants
from astropy.constants import L_sun, M_sun, R_sun, M_earth, R_earth, M_jup, R_jup, au, pc, kpc

# Solar constants
L_sun: Constant  # 3.828e26 W (solar luminosity)
M_sun: Constant  # 1.9891e30 kg (solar mass)
R_sun: Constant  # 695700000.0 m (solar radius)

# Earth constants
M_earth: Constant  # 5.9722e24 kg (Earth mass)
R_earth: Constant  # 6378136.6 m (Earth equatorial radius)

# Jupiter constants  
M_jup: Constant    # 1.8982e27 kg (Jupiter mass)
R_jup: Constant    # 71492000.0 m (Jupiter equatorial radius)

# Distance units
au: Constant       # 149597870700.0 m (astronomical unit)
pc: Constant       # 3.0856775814913674e16 m (parsec)
kpc: Constant      # 3.0856775814913674e19 m (kiloparsec)

# Access different CODATA versions
import astropy.constants.codata2018 as codata2018
import astropy.constants.codata2014 as codata2014  
import astropy.constants.codata2010 as codata2010

# Access different IAU versions
import astropy.constants.iau2015 as iau2015
import astropy.constants.iau2012 as iau2012

# Set default constant systems globally
from astropy import physical_constants, astronomical_constants

# Set CODATA version
physical_constants.set('codata2018')    # 'codata2018', 'codata2014', 'codata2010'

# Set IAU version  
astronomical_constants.set('iau2015')   # 'iau2015', 'iau2012'

# Context managers for temporary constant systems
with physical_constants.set('codata2014'):
    # Use CODATA 2014 constants temporarily
    old_c = c
    
with astronomical_constants.set('iau2012'):
    # Use IAU 2012 constants temporarily  
    old_au = au

# SI units (default)
import astropy.constants.si as si
si.c     # Speed of light in m/s
si.G     # Gravitational constant in m^3 kg^-1 s^-2

# CGS units
import astropy.constants.cgs as cgs  
cgs.c    # Speed of light in cm/s
cgs.G    # Gravitational constant in cm^3 g^-1 s^-2

# Access via main constants module
from astropy.constants import c
c.si     # c in SI units
c.cgs    # c in CGS units

from astropy.constants import c, h, k_B, G, M_sun, L_sun
import astropy.units as u

# Use constants in calculations
photon_energy = h * (c / (500 * u.nm))
print(f"500 nm photon energy: {photon_energy.to(u.eV)}")

# Thermal energy at room temperature
T_room = 300 * u.K
thermal_energy = k_B * T_room
print(f"Thermal energy at 300K: {thermal_energy.to(u.eV)}")

# Solar surface gravity
g_sun = G * M_sun / (695700 * u.km)**2
print(f"Solar surface gravity: {g_sun.to(u.m/u.s**2)}")

from astropy.constants import c, G, M_sun, R_sun, L_sun, sigma_sb
import astropy.units as u

# Solar escape velocity
v_escape_sun = (2 * G * M_sun / R_sun)**0.5
print(f"Solar escape velocity: {v_escape_sun.to(u.km/u.s)}")

# Solar effective temperature from luminosity
T_eff_sun = (L_sun / (4 * np.pi * R_sun**2 * sigma_sb))**(1/4)
print(f"Solar effective temperature: {T_eff_sun.to(u.K)}")

# Schwarzschild radius for solar mass black hole
r_schwarzschild = 2 * G * M_sun / c**2
print(f"Solar mass Schwarzschild radius: {r_schwarzschild.to(u.km)}")

from astropy.constants import G, h

# Access uncertainty information
print(f"G = {G.value} ± {G.uncertainty} {G.unit}")
print(f"Relative uncertainty in G: {G.uncertainty/G.value:.2e}")

print(f"h = {h.value} (exact since 2019 SI redefinition)")
print(f"h uncertainty: {h.uncertainty}")  # Should be 0.0 for exact constants

from astropy.constants import c, G, k_B
import astropy.units as u

# Compare values in different unit systems
print(f"Speed of light:")
print(f"  SI: {c.si}")
print(f"  CGS: {c.cgs}")

print(f"Gravitational constant:")
print(f"  SI: {G.si}")
print(f"  CGS: {G.cgs}")

# Use in calculations with unit conversion
velocity = 0.1 * c
kinetic_energy_cgs = 0.5 * (1 * u.g) * velocity.cgs**2
print(f"Kinetic energy (CGS): {kinetic_energy_cgs}")

from astropy import physical_constants
from astropy.constants import c, G

# Check current constant system
print(f"Current CODATA version: {physical_constants.get()}")
print(f"Current G: {G}")

# Use different constant version
with physical_constants.set('codata2014'):
    print(f"CODATA 2014 G: {G}")
    # Calculations here use CODATA 2014 values

# Direct access to specific versions
import astropy.constants.codata2018 as c18
import astropy.constants.codata2014 as c14

print(f"G (CODATA 2018): {c18.G}")
print(f"G (CODATA 2014): {c14.G}")
print(f"Difference: {(c18.G - c14.G).to(c18.G.unit)}")

from astropy.constants import c, h, k_B, sigma_sb, a0, m_e, m_p
import astropy.units as u
import numpy as np

# Planck function for blackbody radiation
def planck_function(wavelength, temperature):
    \"\"\"Planck function for blackbody spectral radiance.\"\"\"
    return (2 * h * c**2 / wavelength**5) / (np.exp(h * c / (wavelength * k_B * temperature)) - 1)

# Calculate for solar spectrum
wavelength = 500 * u.nm
T_sun = 5778 * u.K
intensity = planck_function(wavelength, T_sun)
print(f"Solar intensity at 500 nm: {intensity.to(u.W / u.m**2 / u.nm / u.sr)}")

# Hydrogen ionization energy  
E_ionization = 13.6 * u.eV  # Rydberg constant * h * c
classical_electron_radius = e**2 / (4 * np.pi * eps0 * m_e * c**2)
print(f"Classical electron radius: {classical_electron_radius.to(u.fm)}")