Support Functions

def cndr(s, t, p):
    """
    Conductivity ratio from salinity, temperature, and pressure.
    
    Calculates the conductivity ratio C(S,T,P)/C(35,15,0) used in
    the PSS-78 salinity scale calculations.
    
    Parameters:
    - s: array_like, salinity [psu (PSS-78)]
    - t: array_like, temperature [°C (ITS-90)]
    - p: array_like, pressure [db]
    
    Returns:
    - array_like: conductivity ratio [dimensionless]
    """

def salrp(r, t, p):
    """
    Conductivity ratio Rp(S,T,P) from conductivity measurements.
    
    Calculates pressure-corrected conductivity ratio for salinity
    determination using PSS-78 algorithms.
    
    Parameters:
    - r: array_like, conductivity ratio
    - t: array_like, temperature [°C (ITS-90)]
    - p: array_like, pressure [db]
    
    Returns:
    - array_like: pressure-corrected conductivity ratio
    """

def salrt(t):
    """
    Conductivity ratio rt(t) for temperature correction.
    
    Temperature-dependent conductivity ratio used in salinity
    calculations following PSS-78 standard.
    
    Parameters:
    - t: array_like, temperature [°C (ITS-90)]
    
    Returns:
    - array_like: temperature conductivity ratio [dimensionless]
    """

def sals(rt, t):
    """
    Salinity from conductivity ratio Rt and temperature.
    
    Core PSS-78 salinity calculation from temperature-corrected
    conductivity ratio.
    
    Parameters:
    - rt: array_like, conductivity ratio Rt
    - t: array_like, temperature [°C (ITS-90)]
    
    Returns:
    - array_like: salinity [psu (PSS-78)]
    """

def salds(rtx, delt):
    """
    Salinity differential dS/d(√Rt) for iterative calculations.
    
    Calculates the derivative of salinity with respect to the square root
    of conductivity ratio for Newton-Raphson salinity iterations.
    
    Parameters:
    - rtx: array_like, √Rt (square root of conductivity ratio)
    - delt: array_like, temperature difference from 15°C
    
    Returns:
    - array_like: salinity differential
    """

def smow(t):
    """
    Standard Mean Ocean Water (SMOW) density.
    
    Calculates the density of Standard Mean Ocean Water as a function
    of temperature, providing a reference for oceanographic calculations.
    
    Parameters:
    - t: array_like, temperature [°C (ITS-90)]
    
    Returns:
    - array_like: SMOW density [kg/m³]
    """

def T68conv(T90):
    """
    Convert ITS-90 temperature to IPTS-68.
    
    Linear transformation: T68 = T90 * 1.00024
    Accurate within 0.5°C over oceanographic temperature range.
    
    Parameters:
    - T90: array_like, temperature [°C (ITS-90)]
    
    Returns:
    - array_like: temperature [°C (IPTS-68)]
    """

def T90conv(t, t_type="T68"):
    """
    Convert IPTS-68 or IPTS-48 temperature to ITS-90.
    
    T68 applies to data collected between 01/10/1968 and 31/12/1989.
    T48 applies to data collected prior to 31/12/1967.
    
    Parameters:
    - t: array_like, temperature [°C (IPTS-68) or (IPTS-48)]
    - t_type: str, temperature scale type ("T68" or "T48"), default "T68"
    
    Returns:
    - array_like: temperature [°C (ITS-90)]
    """

def seck(s, t, p=0):
    """
    Secant bulk modulus of seawater.
    
    Calculates the secant bulk modulus (K) which is the reciprocal
    of compressibility, used in equation of state calculations.
    
    Parameters:
    - s: array_like, salinity [psu (PSS-78)]
    - t: array_like, temperature [°C (ITS-90)]
    - p: array_like, pressure [db], default 0
    
    Returns:
    - array_like: secant bulk modulus [bars]
    """

import seawater as sw
import numpy as np

# Example: Converting conductivity measurements to salinity
# Typical CTD (Conductivity-Temperature-Depth) data processing

# Raw conductivity measurements (example data)
temperatures = np.array([20.0, 15.0, 10.0, 5.0, 2.0])  # °C
pressures = np.array([0, 50, 100, 200, 500])  # db
conductivity_ratios = np.array([1.000, 0.985, 0.970, 0.955, 0.940])

# Step 1: Calculate salinity from conductivity
salinities = sw.salt(conductivity_ratios, temperatures, pressures)

print("CTD Data Processing Example:")
print("Depth(m) | Temp(°C) | Cond.Ratio | Salinity(psu)")
print("-" * 50)
for i in range(len(temperatures)):
    depth = sw.dpth(pressures[i], 45.0)  # Convert pressure to depth at 45°N
    print(f"{depth:6.0f}   | {temperatures[i]:6.1f}   | {conductivity_ratios[i]:8.3f}   | {salinities[i]:10.3f}")

# Step 2: Verify by converting back to conductivity
calculated_ratios = sw.cndr(salinities, temperatures, pressures)

print("\\nVerification (Salinity → Conductivity):")
print("Original | Calculated | Difference")
print("-" * 35)
for orig, calc in zip(conductivity_ratios, calculated_ratios):
    diff = abs(orig - calc)
    print(f"{orig:.6f} | {calc:.6f}   | {diff:.2e}")

import seawater as sw
import numpy as np
import matplotlib.pyplot as plt

# Calculate bulk modulus across oceanographic conditions
salinities = [0, 20, 35]  # Fresh, brackish, seawater
temperatures = np.linspace(0, 30, 31)
pressures = [0, 100, 500, 1000]  # Surface to deep ocean

plt.figure(figsize=(12, 8))

for i, pressure in enumerate(pressures):
    plt.subplot(2, 2, i+1)
    
    for salinity in salinities:
        bulk_modulus = sw.seck(salinity, temperatures, pressure)
        plt.plot(temperatures, bulk_modulus, linewidth=2, 
                label=f'S = {salinity} psu')
    
    plt.xlabel('Temperature (°C)')
    plt.ylabel('Bulk Modulus (bars)')
    plt.title(f'Bulk Modulus at {pressure} db')
    plt.legend()
    plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Calculate compressibility (inverse of bulk modulus)
# Standard oceanographic conditions
s_std, t_std, p_std = 35.0, 15.0, 100.0
bulk_mod = sw.seck(s_std, t_std, p_std)
compressibility = 1.0 / bulk_mod  # bars⁻¹

print(f"\\nSeawater properties at S={s_std}, T={t_std}°C, P={p_std} db:")
print(f"Bulk modulus: {bulk_mod:.0f} bars")
print(f"Compressibility: {compressibility:.2e} bars⁻¹")
print(f"Compressibility: {compressibility*1e5:.2e} Pa⁻¹")  # Convert to SI units

# Compare with pure water
smow_density = sw.smow(temperatures)
print(f"\\nSMOW density range: {smow_density.min():.3f} to {smow_density.max():.3f} kg/m³")

# Temperature effect on SMOW density
plt.figure(figsize=(10, 6))
plt.subplot(1, 2, 1)
plt.plot(temperatures, smow_density, 'b-', linewidth=2)
plt.xlabel('Temperature (°C)')
plt.ylabel('SMOW Density (kg/m³)')
plt.title('Standard Mean Ocean Water Density')
plt.grid(True, alpha=0.3)

# Compare SMOW with seawater density at same temperature
seawater_density_surface = sw.dens0(35.0, temperatures)
plt.subplot(1, 2, 2)
plt.plot(temperatures, smow_density, 'b-', linewidth=2, label='SMOW')
plt.plot(temperatures, seawater_density_surface, 'r-', linewidth=2, label='Seawater (S=35)')
plt.xlabel('Temperature (°C)')
plt.ylabel('Density (kg/m³)')
plt.title('SMOW vs Seawater Density')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Density difference due to salinity
density_diff = seawater_density_surface - smow_density
print(f"\\nDensity increase due to S=35 psu:")
print(f"At 0°C: {density_diff[0]:.2f} kg/m³")
print(f"At 20°C: {density_diff[20]:.2f} kg/m³")

import seawater as sw
import numpy as np

# Detailed conductivity-salinity relationship analysis
# Simulate a range of oceanographic conditions

print("Detailed Conductivity-Salinity Analysis")
print("=" * 50)

# Test conditions
test_conditions = [
    (35.000, 15.000, 0),      # Standard seawater
    (0.000, 15.000, 0),      # Fresh water
    (5.000, 10.000, 50),     # Brackish water
    (34.500, 2.000, 1000),   # Deep cold water
    (36.500, 25.000, 100),   # Warm saline water
]

print("Condition | S(psu) | T(°C) | P(db) | C.Ratio | Salinity_calc | Error")
print("-" * 75)

for i, (s_true, t, p) in enumerate(test_conditions):
    # Calculate conductivity ratio from known salinity
    c_ratio = sw.cndr(s_true, t, p)
    
    # Calculate salinity back from conductivity ratio
    s_calc = sw.salt(c_ratio, t, p)
    
    # Calculate error
    error = abs(s_calc - s_true)
    
    print(f"Test {i+1:1d}    | {s_true:6.3f} | {t:5.1f} | {p:4.0f}  | "
          f"{c_ratio:7.4f} | {s_calc:11.6f} | {error:.2e}")

# Test the component functions
print("\\nComponent Function Testing:")
print("-" * 40)

s, t, p = 35.0, 15.0, 100.0
print(f"Test conditions: S={s}, T={t}°C, P={p} db")

# Calculate individual components
rt = sw.salrt(t)
print(f"salrt({t}) = {rt:.6f}")

# This would require access to intermediate calculations
# that aren't directly exposed in the public API
print("(Other component functions require intermediate values)")

# Note: Temperature scale conversions are handled internally
# The library expects ITS-90 input temperatures
print("\\nNote: Temperature scale conversions are handled internally by the library.")
print("All input temperatures should be in ITS-90 scale.")