pychnosz 1.1.1__cp311-cp311-macosx_10_13_x86_64.whl

pychnosz/geochemistry/redox.py

@@ -0,0 +1,500 @@
+"""
+Redox reactions and Eh-pH diagram calculations for CHNOSZ.
+
+This module implements redox equilibria calculations, Eh-pH diagrams,
+and electron activity (pe) calculations for environmental geochemistry.
+"""
+
+import numpy as np
+import pandas as pd
+from typing import Union, Dict, List, Optional, Tuple, Any
+import warnings
+
+from ..core.subcrt import subcrt
+from ..core.equilibrium import EquilibriumSolver
+
+
+class RedoxCalculator:
+    """
+    Redox equilibria calculator for geochemical systems.
+    
+    This class handles redox reactions, pe-pH diagrams, and
+    electron activity calculations.
+    """
+    
+    def __init__(self):
+        """Initialize the redox calculator."""
+        self.equilibrium_solver = EquilibriumSolver()
+        
+        # Standard electrode potentials (V) at 25°C
+        self.standard_potentials = {
+            'O2/H2O': 1.229,
+            'H+/H2': 0.000,
+            'Fe+3/Fe+2': 0.771,
+            'NO3-/NO2-': 0.835,
+            'SO4-2/HS-': -0.217,
+            'CO2/CH4': -0.244,
+            'N2/NH4+': -0.277,
+            'Fe+2/Fe': -0.447,
+            'S/HS-': -0.065,
+        }
+        
+        # Common redox couples and their reactions
+        self.redox_reactions = {
+            # Oxygen reduction
+            'O2_H2O': {'O2': 1, 'H+': 4, 'e-': 4, 'H2O': -2},
+            'H2O_H2': {'H2O': 2, 'e-': 2, 'H2': -1, 'OH-': -2},
+            
+            # Iron redox
+            'Fe3_Fe2': {'Fe+3': 1, 'e-': 1, 'Fe+2': -1},
+            'Fe2_Fe': {'Fe+2': 1, 'e-': 2, 'Fe': -1},
+            'Fe2O3_Fe2': {'Fe2O3': 1, 'H+': 6, 'e-': 2, 'Fe+2': -2, 'H2O': -3},
+            
+            # Nitrogen redox
+            'NO3_NO2': {'NO3-': 1, 'H+': 2, 'e-': 2, 'NO2-': -1, 'H2O': -1},
+            'NO2_NH4': {'NO2-': 1, 'H+': 8, 'e-': 6, 'NH4+': -1, 'H2O': -2},
+            
+            # Sulfur redox
+            'SO4_HS': {'SO4-2': 1, 'H+': 9, 'e-': 8, 'HS-': -1, 'H2O': -4},
+            'S_HS': {'S': 1, 'H+': 1, 'e-': 2, 'HS-': -1},
+            
+            # Carbon redox
+            'CO2_CH4': {'CO2': 1, 'H+': 8, 'e-': 8, 'CH4': -1, 'H2O': -2},
+            'HCO3_CH4': {'HCO3-': 1, 'H+': 9, 'e-': 8, 'CH4': -1, 'H2O': -3}
+        }
+    
+    def eh_ph_diagram(self, element: str, 
+                     pH_range: Tuple[float, float] = (0, 14),
+                     pe_range: Tuple[float, float] = (-10, 15),
+                     T: float = 298.15, P: float = 1.0,
+                     total_concentration: float = 1e-6,
+                     resolution: int = 100) -> Dict[str, Any]:
+        """
+        Create Eh-pH (pe-pH) diagram for an element.
+        
+        Parameters
+        ----------
+        element : str
+            Element symbol (e.g., 'Fe', 'S', 'N', 'C')
+        pH_range : tuple, default (0, 14)
+            pH range for diagram
+        pe_range : tuple, default (-10, 15)
+            pe (electron activity) range
+        T : float, default 298.15
+            Temperature in Kelvin
+        P : float, default 1.0
+            Pressure in bar
+        total_concentration : float, default 1e-6
+            Total element concentration (molal)
+        resolution : int, default 100
+            Grid resolution
+            
+        Returns
+        -------
+        dict
+            Eh-pH diagram data
+        """
+        
+        pH_grid = np.linspace(pH_range[0], pH_range[1], resolution)
+        pe_grid = np.linspace(pe_range[0], pe_range[1], resolution)
+        pH_mesh, pe_mesh = np.meshgrid(pH_grid, pe_grid)
+        
+        # Get species for this element
+        element_species = self._get_element_species(element)
+        
+        if not element_species:
+            raise ValueError(f"No species found for element {element}")
+        
+        # Calculate predominance at each point
+        predominant = np.zeros_like(pH_mesh, dtype=int)
+        activities = {species: np.zeros_like(pH_mesh) for species in element_species}
+        
+        for i in range(len(pe_grid)):
+            for j in range(len(pH_grid)):
+                pH, pe = pH_mesh[i, j], pe_mesh[i, j]
+                
+                # Calculate speciation at this point
+                spec_result = self._calculate_redox_speciation(
+                    element_species, pH, pe, T, P, total_concentration)
+                
+                # Find predominant species
+                max_activity = -np.inf
+                max_idx = 0
+                
+                for k, species in enumerate(element_species):
+                    activity = spec_result.get(species, 1e-20)
+                    activities[species][i, j] = activity
+                    
+                    if np.log10(activity) > max_activity:
+                        max_activity = np.log10(activity)
+                        max_idx = k
+                
+                predominant[i, j] = max_idx
+        
+        # Add water stability limits
+        water_limits = self._water_stability_lines(pH_grid, T, P)
+        
+        return {
+            'pH': pH_grid,
+            'pe': pe_grid,
+            'pH_mesh': pH_mesh,
+            'pe_mesh': pe_mesh,
+            'predominant': predominant,
+            'activities': activities,
+            'species_names': element_species,
+            'water_limits': water_limits,
+            'element': element,
+            'T': T,
+            'P': P,
+            'total_concentration': total_concentration
+        }
+    
+    def pe_calculation(self, redox_couple: Union[str, Dict[str, float]],
+                      concentrations: Dict[str, float],
+                      pH: float = 7.0, T: float = 298.15, P: float = 1.0) -> float:
+        """
+        Calculate pe (electron activity) for a redox couple.
+        
+        Parameters
+        ----------
+        redox_couple : str or dict
+            Redox couple name or reaction dictionary
+        concentrations : dict
+            Species concentrations {species: concentration}
+        pH : float, default 7.0
+            Solution pH
+        T : float, default 298.15
+            Temperature in Kelvin
+        P : float, default 1.0
+            Pressure in bar
+            
+        Returns
+        -------
+        float
+            pe value
+        """
+        
+        if isinstance(redox_couple, str):
+            if redox_couple not in self.redox_reactions:
+                raise ValueError(f"Unknown redox couple: {redox_couple}")
+            reaction = self.redox_reactions[redox_couple]
+        else:
+            reaction = redox_couple
+        
+        # Calculate equilibrium constant
+        try:
+            species_names = [sp for sp in reaction.keys() if sp != 'e-']
+            coefficients = [reaction[sp] for sp in species_names]
+            
+            result = subcrt(species_names, coefficients, T=T, P=P, show=False)
+            if result.out is not None and 'logK' in result.out.columns:
+                logK = result.out['logK'].iloc[0]
+            else:
+                logK = 0.0
+        except Exception as e:
+            warnings.warn(f"Could not calculate logK: {e}")
+            logK = 0.0
+        
+        # Apply Nernst equation
+        n_electrons = abs(reaction.get('e-', 1))  # Number of electrons
+        
+        # Calculate activity quotient
+        log_Q = 0.0
+        for species, coeff in reaction.items():
+            if species == 'e-':
+                continue
+            elif species == 'H+':
+                activity = 10**(-pH)
+            elif species in concentrations:
+                activity = concentrations[species]
+                # Apply activity coefficients if needed
+                gamma = self._get_activity_coefficient(species, concentrations, T)
+                activity *= gamma
+            else:
+                activity = 1.0  # Default for species not specified
+            
+            if activity > 0:
+                log_Q += coeff * np.log10(activity)
+        
+        # Nernst equation: pe = pe° + (1/n) * log(Q)
+        # where pe° = logK/n for the half-reaction
+        pe = logK / n_electrons + log_Q / n_electrons
+        
+        return pe
+    
+    def eh_from_pe(self, pe: float, T: float = 298.15) -> float:
+        """
+        Convert pe to Eh (redox potential).
+        
+        Parameters
+        ----------
+        pe : float
+            Electron activity (pe)
+        T : float, default 298.15
+            Temperature in Kelvin
+            
+        Returns
+        -------
+        float
+            Redox potential (Eh) in Volts
+        """
+        
+        # Eh = (RT/F) * ln(10) * pe
+        # where R = 8.314 J/(mol·K), F = 96485 C/mol
+        RT_F = 8.314 * T / 96485
+        Eh = RT_F * 2.302585 * pe  # ln(10) = 2.302585
+        
+        return Eh
+    
+    def pe_from_eh(self, eh: float, T: float = 298.15) -> float:
+        """
+        Convert Eh (redox potential) to pe.
+        
+        Parameters
+        ----------
+        eh : float
+            Redox potential (Eh) in Volts
+        T : float, default 298.15
+            Temperature in Kelvin
+            
+        Returns
+        -------
+        float
+            Electron activity (pe)
+        """
+        
+        # pe = F * Eh / (RT * ln(10))
+        RT_F = 8.314 * T / 96485
+        pe = eh / (RT_F * 2.302585)
+        
+        return pe
+    
+    def oxygen_fugacity(self, pe: float, pH: float = 7.0, 
+                       T: float = 298.15, P: float = 1.0) -> float:
+        """
+        Calculate oxygen fugacity from pe and pH.
+        
+        Parameters
+        ----------
+        pe : float
+            Electron activity
+        pH : float, default 7.0
+            Solution pH
+        T : float, default 298.15
+            Temperature in Kelvin
+        P : float, default 1.0
+            Pressure in bar
+            
+        Returns
+        -------
+        float
+            log fO2 (log oxygen fugacity)
+        """
+        
+        # O2 + 4H+ + 4e- = 2H2O
+        # At equilibrium: log fO2 = 4*pe + 4*pH - logK
+        
+        try:
+            # Calculate logK for oxygen-water reaction
+            result = subcrt(['O2', 'H+', 'H2O'], [1, 4, -2], T=T, P=P, show=False)
+            if result.out is not None and 'logK' in result.out.columns:
+                logK = result.out['logK'].iloc[0]
+            else:
+                logK = 83.1  # Approximate value at 25°C
+        except:
+            logK = 83.1
+        
+        log_fO2 = 4 * pe + 4 * pH - logK
+        
+        return log_fO2
+    
+    def _get_element_species(self, element: str) -> List[str]:
+        """Get list of species containing the specified element."""
+        
+        # Simplified species lists for common elements
+        element_species = {
+            'Fe': ['Fe+2', 'Fe+3', 'Fe2O3', 'FeOH+', 'Fe(OH)2', 'Fe(OH)3'],
+            'S': ['SO4-2', 'SO3-2', 'S2O3-2', 'HS-', 'S0', 'S-2'],
+            'N': ['NO3-', 'NO2-', 'NH4+', 'NH3', 'N2O', 'N2'],
+            'C': ['CO2', 'HCO3-', 'CO3-2', 'CH4', 'HCOOH', 'CH3COO-'],
+            'Mn': ['Mn+2', 'MnO4-', 'MnO2', 'Mn+3', 'MnOH+'],
+            'As': ['AsO4-3', 'AsO3-3', 'H3AsO4', 'H3AsO3', 'As0']
+        }
+        
+        return element_species.get(element, [f'{element}+2', f'{element}+3'])
+    
+    def _calculate_redox_speciation(self, species: List[str], pH: float, pe: float,
+                                  T: float, P: float, total_conc: float) -> Dict[str, float]:
+        """Calculate speciation at given pH and pe."""
+        
+        # Simplified speciation calculation
+        # Full implementation would solve equilibrium system
+        
+        activities = {}
+        
+        for sp in species:
+            # Simplified pe-pH dependence
+            if '+' in sp:  # Cations (more stable at low pH, high pe)
+                charge = self._extract_charge(sp)
+                log_activity = -6 + charge * (14 - pH) / 14 + pe / 10
+            elif '-' in sp:  # Anions (more stable at high pH, high pe)  
+                charge = abs(self._extract_charge(sp))
+                log_activity = -6 + charge * pH / 14 + pe / 10
+            else:  # Neutral (less pH/pe dependence)
+                log_activity = -6 + (pe - pH) / 20
+            
+            activities[sp] = 10**log_activity
+        
+        # Normalize to total concentration
+        total_calculated = sum(activities.values())
+        if total_calculated > 0:
+            factor = total_conc / total_calculated
+            activities = {sp: act * factor for sp, act in activities.items()}
+        
+        return activities
+    
+    def _extract_charge(self, species: str) -> int:
+        """Extract charge from species name."""
+        
+        if '+' in species:
+            parts = species.split('+')
+            if len(parts) > 1 and parts[-1].isdigit():
+                return int(parts[-1])
+            else:
+                return 1
+        elif '-' in species:
+            parts = species.split('-')
+            if len(parts) > 1 and parts[-1].isdigit():
+                return -int(parts[-1])
+            else:
+                return -1
+        else:
+            return 0
+    
+    def _water_stability_lines(self, pH_values: np.ndarray, 
+                              T: float, P: float) -> Dict[str, np.ndarray]:
+        """Calculate water stability limits (H2O/H2 and O2/H2O)."""
+        
+        # Upper limit: O2/H2O
+        # O2 + 4H+ + 4e- = 2H2O
+        # pe = 20.75 - pH (at 25°C, 1 atm O2)
+        pe_upper = 20.75 - pH_values
+        
+        # Lower limit: H2O/H2
+        # 2H2O + 2e- = H2 + 2OH-
+        # pe = -pH (at 25°C, 1 atm H2)
+        pe_lower = -pH_values
+        
+        # Temperature corrections (simplified)
+        if T != 298.15:
+            dT = T - 298.15
+            pe_upper += dT * 0.001  # Small temperature dependence
+            pe_lower -= dT * 0.001
+        
+        return {
+            'upper': pe_upper,  # O2/H2O line
+            'lower': pe_lower   # H2O/H2 line
+        }
+    
+    def _get_activity_coefficient(self, species: str, composition: Dict[str, float],
+                                 T: float) -> float:
+        """Get activity coefficient for species."""
+        
+        # Simplified - would use proper activity models
+        charge = abs(self._extract_charge(species))
+        
+        if charge == 0:
+            return 1.0
+        else:
+            # Simple ionic strength correction
+            I = 0.001  # Assume low ionic strength
+            return 10**(-0.509 * charge**2 * np.sqrt(I))
+
+
+# Global redox calculator
+_redox_calculator = RedoxCalculator()
+
+
+def eh_ph(element: str, **kwargs) -> Dict[str, Any]:
+    """
+    Create Eh-pH diagram for an element.
+    
+    Parameters
+    ----------
+    element : str
+        Element symbol
+    **kwargs
+        Additional parameters for eh_ph_diagram()
+        
+    Returns
+    -------
+    dict
+        Eh-pH diagram data
+    """
+    
+    return _redox_calculator.eh_ph_diagram(element, **kwargs)
+
+
+def pe(redox_couple: Union[str, Dict[str, float]], 
+      concentrations: Dict[str, float], **kwargs) -> float:
+    """
+    Calculate pe for a redox couple.
+    
+    Parameters
+    ----------
+    redox_couple : str or dict
+        Redox couple or reaction
+    concentrations : dict
+        Species concentrations
+    **kwargs
+        Additional parameters
+        
+    Returns
+    -------
+    float
+        pe value
+    """
+    
+    return _redox_calculator.pe_calculation(redox_couple, concentrations, **kwargs)
+
+
+def eh(pe_value: float, T: float = 298.15) -> float:
+    """
+    Convert pe to Eh.
+    
+    Parameters
+    ----------
+    pe_value : float
+        Electron activity
+    T : float, default 298.15
+        Temperature in Kelvin
+        
+    Returns
+    -------
+    float
+        Eh in Volts
+    """
+    
+    return _redox_calculator.eh_from_pe(pe_value, T)
+
+
+def logfO2(pe_value: float, pH: float = 7.0, **kwargs) -> float:
+    """
+    Calculate log oxygen fugacity.
+    
+    Parameters
+    ----------
+    pe_value : float
+        Electron activity
+    pH : float, default 7.0
+        Solution pH
+    **kwargs
+        Additional parameters
+        
+    Returns
+    -------
+    float
+        log fO2
+    """
+    
+    return _redox_calculator.oxygen_fugacity(pe_value, pH, **kwargs)

pychnosz/models/__init__.py

@@ -0,0 +1,47 @@
+"""Equation of state models and water property models for CHNOSZ."""
+
+from .water import water, available_properties, get_water_models, compare_models, WaterModelError
+
+# Import Fortran-backed SUPCRT92 (falls back to Python if Fortran unavailable)
+from .supcrt92_fortran import water_SUPCRT92, SUPCRT92Water
+
+# Import HKF equation of state functions
+from .hkf import hkf, gfun, convert_cm3bar
+
+# Import CGL equation of state functions
+from .cgl import cgl, quartz_coesite
+
+# Import HKF helper functions
+from .hkf_helpers import calc_logK, calc_G_TP, G2logK, dissrxn2logK, OBIGT2eos
+
+# Optional imports for modules that may not exist yet
+try:
+    from .hkf import HKF
+except ImportError:
+    HKF = None
+
+try:
+    from .cgl import CGL
+except ImportError:
+    CGL = None
+
+try:
+    from .berman import Berman
+except ImportError:
+    Berman = None
+
+__all__ = [
+    'water', 'available_properties', 'get_water_models', 'compare_models', 'WaterModelError',
+    'water_SUPCRT92', 'SUPCRT92Water',
+    'hkf', 'gfun', 'convert_cm3bar',
+    'cgl', 'quartz_coesite',
+    'calc_logK', 'calc_G_TP', 'G2logK', 'dissrxn2logK', 'OBIGT2eos'
+]
+
+# Add optional functions if they exist
+if HKF is not None:
+    __all__.append('HKF')
+if CGL is not None:
+    __all__.append('CGL')
+if Berman is not None:
+    __all__.append('Berman')

pychnosz/models/archer_wang.py

@@ -0,0 +1,165 @@
+"""
+Archer & Wang (1990) dielectric constant correlation for water.
+
+This module implements the accurate dielectric constant calculation
+used in the original R version of CHNOSZ.
+
+Reference:
+Archer, D. G., and Wang, P. (1990) The dielectric constant of water 
+and Debye-Hückel limiting law slopes. Journal of Physical and Chemical 
+Reference Data, 19, 371-411.
+"""
+
+import numpy as np
+import warnings
+from typing import Union
+
+
+def water_AW90(T: Union[float, np.ndarray] = 298.15, 
+               rho: Union[float, np.ndarray] = 1000.0, 
+               P: Union[float, np.ndarray] = 0.1) -> Union[float, np.ndarray]:
+    """
+    Calculate dielectric constant of water using Archer & Wang (1990) correlation.
+    
+    This is a direct Python translation of the R function water.AW90() from
+    the original CHNOSZ package.
+    
+    Parameters
+    ----------
+    T : float or array
+        Temperature in Kelvin
+    rho : float or array  
+        Density in kg/m³
+    P : float or array
+        Pressure in MPa
+        
+    Returns
+    -------
+    float or array
+        Dielectric constant (dimensionless)
+        
+    Examples
+    --------
+    >>> # Water at 25°C, 1000 kg/m³, 0.1 MPa
+    >>> eps = water_AW90(298.15, 1000.0, 0.1)
+    >>> print(f"Dielectric constant: {eps:.1f}")  # Should be ~78.4
+    """
+    
+    # Convert inputs to arrays
+    T = np.atleast_1d(np.asarray(T, dtype=float))
+    rho = np.atleast_1d(np.asarray(rho, dtype=float))  
+    P = np.atleast_1d(np.asarray(P, dtype=float))
+    
+    # Make all arrays the same length
+    max_len = max(len(T), len(rho), len(P))
+    if len(T) < max_len:
+        T = np.resize(T, max_len)
+    if len(rho) < max_len:
+        rho = np.resize(rho, max_len)
+    if len(P) < max_len:
+        P = np.resize(P, max_len)
+    
+    # Table 2 coefficients from Archer & Wang (1990)
+    b = np.array([
+        -4.044525E-2, 103.6180,    75.32165,
+        -23.23778,    -3.548184,   -1246.311,
+        263307.7,     -6.928953E-1, -204.4473
+    ])
+    
+    # Physical constants
+    alpha = 18.1458392E-30  # polarizability, m³
+    mu = 6.1375776E-30      # dipole moment, C·m  
+    N_A = 6.0221367E23      # Avogadro's number, mol⁻¹
+    k = 1.380658E-23        # Boltzmann constant, J·K⁻¹
+    M = 0.0180153           # molar mass of water, kg/mol
+    rho_0 = 1000.0          # reference density, kg/m³
+    epsilon_0 = 8.8541878E-12  # permittivity of vacuum, C²·J⁻¹·m⁻¹
+    
+    # Initialize output
+    epsilon = np.full_like(T, np.nan)
+    
+    for i in range(len(T)):
+        T_i = T[i]
+        rho_i = rho[i]
+        P_i = P[i]
+        
+        # Skip invalid conditions
+        if np.isnan(T_i) or np.isnan(rho_i) or np.isnan(P_i):
+            continue
+        if T_i <= 0 or rho_i <= 0 or P_i < 0:
+            continue
+            
+        # Equation 3: rho function 
+        def rhofun():
+            return (b[0]*P_i/T_i + 
+                    b[1]/np.sqrt(T_i) + 
+                    b[2]/(T_i-215) + 
+                    b[3]/np.sqrt(T_i-215) + 
+                    b[4]/(T_i-215)**0.25 + 
+                    np.exp(b[5]/T_i + b[6]/T_i**2 + b[7]*P_i/T_i + b[8]*P_i/T_i**2))
+        
+        # g function
+        def gfun():
+            return rhofun() * rho_i/rho_0 + 1.0
+        
+        # mu function  
+        def mufun():
+            return gfun() * mu**2
+        
+        # Right-hand side of Equation 1
+        V_m = M / rho_i  # molar volume, m³/mol
+        epsfun_rhs = N_A * (alpha + mufun()/(3*epsilon_0*k*T_i)) / (3*V_m)
+        
+        # Solve quadratic equation (Equation 1 rearranged)
+        # Original: (ε-1)(2ε+1)/(9ε) = rhs
+        # Rearranged to: 2ε² - (9*rhs + 1)ε + 1 = 0
+        # Using quadratic formula with positive root
+        discriminant = (9*epsfun_rhs + 1)**2 + 8
+        if discriminant < 0:
+            warnings.warn(f'water_AW90: negative discriminant at T={T_i:.1f} K, '
+                         f'rho={rho_i:.0f} kg/m3', stacklevel=2)
+            continue
+            
+        epsilon_calc = (9*epsfun_rhs + 1 + np.sqrt(discriminant)) / 4.0
+        
+        # Check for reasonable result
+        if epsilon_calc < 1.0 or epsilon_calc > 200.0:
+            warnings.warn(f'water_AW90: unrealistic dielectric constant {epsilon_calc:.1f} '
+                         f'at T={T_i:.1f} K, rho={rho_i:.0f} kg/m3', stacklevel=2)
+            continue
+            
+        epsilon[i] = epsilon_calc
+    
+    # Return scalar if input was scalar
+    if len(epsilon) == 1:
+        return epsilon[0]
+    else:
+        return epsilon
+
+
+if __name__ == "__main__":
+    # Test the function
+    print("Testing Archer & Wang (1990) dielectric constant correlation")
+    print("=" * 60)
+    
+    # Test conditions from R CHNOSZ
+    test_conditions = [
+        (298.15, 997.0, 0.1),      # 25°C, ~997 kg/m³, 0.1 MPa
+        (373.15, 958.0, 0.1),      # 100°C
+        (273.15, 1000.0, 0.1),     # 0°C  
+        (473.15, 800.0, 1.0),      # 200°C, 1 MPa
+    ]
+    
+    for T, rho, P in test_conditions:
+        eps = water_AW90(T, rho, P)
+        print(f"T = {T:6.1f} K, ρ = {rho:6.0f} kg/m³, P = {P:5.1f} MPa: ε = {eps:6.1f}")
+    
+    # Test array input
+    print("\nTesting array input:")
+    T_array = np.array([273.15, 298.15, 373.15])
+    rho_array = np.array([1000.0, 997.0, 958.0]) 
+    P_array = np.array([0.1, 0.1, 0.1])
+    
+    eps_array = water_AW90(T_array, rho_array, P_array)
+    for i in range(len(T_array)):
+        print(f"T = {T_array[i]:6.1f} K: ε = {eps_array[i]:6.1f}")