qualia_core_db/specialized_libs/chemistry_modeling/

kinetics.rs

use super::*;

/// Reaction analyzer for chemical reaction analysis
pub struct ReactionAnalyzer {
    reaction_network: ReactionNetwork,
    kinetics_calculator: KineticsCalculator,
    thermodynamics_calculator: ThermodynamicsCalculator,
}

/// Reaction network
pub struct ReactionNetwork {
    reactions: HashMap<String, Reaction>,
    species: HashMap<String, Species>,
    pathways: Vec<ReactionPathway>,
}

/// Reactions
#[derive(Debug, Clone)]
pub struct Reaction {
    pub reaction_id: String,
    pub reaction_name: String,
    pub reactants: Vec<String>,
    pub products: Vec<String>,
    pub reaction_type: ReactionType,
    pub mechanism: ReactionMechanism,
}

/// Reaction types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ReactionType {
    Elementary,
    Complex,
    Catalytic,
    Chain,
    Photochemical,
    Electrochemical,
}

/// Reaction mechanisms
#[derive(Debug, Clone)]
pub struct ReactionMechanism {
    pub mechanism_id: String,
    pub steps: Vec<ReactionStep>,
    pub intermediates: Vec<String>,
}

/// Reaction steps
#[derive(Debug, Clone)]
pub struct ReactionStep {
    pub step_id: String,
    pub reactants: Vec<String>,
    pub products: Vec<String>,
    pub rate_constant: f64,
    pub activation_energy: f64,
}

/// Species
#[derive(Debug, Clone)]
pub struct Species {
    pub species_id: String,
    pub species_name: String,
    pub formula: String,
    pub molecular_weight: f64,
    pub properties: SpeciesProperties,
}

/// Species properties
#[derive(Debug, Clone)]
pub struct SpeciesProperties {
    pub enthalpy: f64,
    pub entropy: f64,
    pub gibbs_free_energy: f64,
    pub heat_capacity: f64,
}

/// Reaction pathways
#[derive(Debug, Clone)]
pub struct ReactionPathway {
    pub pathway_id: String,
    pub pathway_name: String,
    pub reactions: Vec<String>,
    pub branching_ratios: Vec<f64>,
}

/// Kinetics calculator
pub struct KineticsCalculator {
    rate_laws: HashMap<String, RateLaw>,
    rate_constants: HashMap<String, RateConstant>,
    reaction_rates: HashMap<String, f64>,
}

/// Rate laws
#[derive(Debug, Clone)]
pub struct RateLaw {
    pub law_id: String,
    pub law_type: RateLawType,
    pub rate_expression: String,
    pub parameters: RateLawParameters,
}

/// Rate law types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum RateLawType {
    Elementary,
    MichaelisMenten,
    Hill,
    Custom,
}

/// Rate law parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLawParameters {
    pub rate_constant: f64,
    pub reaction_orders: Vec<f64>,
    pub saturation_constants: Vec<f64>,
}

/// Rate constants
#[derive(Debug, Clone)]
pub struct RateConstant {
    pub constant_id: String,
    pub value: f64,
    pub temperature_dependence: TemperatureDependence,
    pub pressure_dependence: PressureDependence,
}

/// Temperature dependence
#[derive(Debug, Clone)]
pub struct TemperatureDependence {
    pub arrhenius_parameters: ArrheniusParameters,
    pub modified_arrhenius: Option<ModifiedArrheniusParameters>,
}

/// Arrhenius parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArrheniusParameters {
    pub pre_exponential: f64,
    pub activation_energy: f64,
}

/// Modified Arrhenius parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModifiedArrheniusParameters {
    pub pre_exponential: f64,
    pub activation_energy: f64,
    pub temperature_exponent: f64,
}

/// Pressure dependence
#[derive(Debug, Clone)]
pub struct PressureDependence {
    pub fall_off_parameters: FallOffParameters,
    pub third_body_efficiency: f64,
}

/// Fall-off parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FallOffParameters {
    pub low_pressure_limit: f64,
    pub high_pressure_limit: f64,
    pub fall_off_exponent: f64,
}

/// Thermodynamics calculator
pub struct ThermodynamicsCalculator {
    thermodynamic_data: HashMap<String, ThermodynamicData>,
    equilibrium_calculator: EquilibriumCalculator,
    phase_calculator: PhaseCalculator,
}

/// Thermodynamic data
#[derive(Debug, Clone)]
pub struct ThermodynamicData {
    pub data_id: String,
    pub temperature_range: (f64, f64),
    pub enthalpy: f64,
    pub entropy: f64,
    pub gibbs_free_energy: f64,
    pub heat_capacity: f64,
}

/// Equilibrium calculator
pub struct EquilibriumCalculator {
    equilibrium_constant: EquilibriumConstant,
    reaction_quotient: ReactionQuotient,
    gibbs_energy: GibbsEnergy,
}

/// Equilibrium constant
#[derive(Debug, Clone)]
pub struct EquilibriumConstant {
    pub value: f64,
    pub temperature: f64,
    pub pressure: f64,
}

/// Reaction quotient
#[derive(Debug, Clone)]
pub struct ReactionQuotient {
    pub value: f64,
    pub concentrations: HashMap<String, f64>,
}

/// Gibbs energy
#[derive(Debug, Clone)]
pub struct GibbsEnergy {
    pub standard_gibbs: f64,
    pub actual_gibbs: f64,
    pub delta_g: f64,
}

/// Phase calculator
pub struct PhaseCalculator {
    phase_diagrams: HashMap<String, PhaseDiagram>,
    phase_transitions: HashMap<String, PhaseTransition>,
    phase_equilibria: HashMap<String, PhaseEquilibrium>,
}

/// Phase diagrams
#[derive(Debug, Clone)]
pub struct PhaseDiagram {
    pub diagram_id: String,
    pub phases: Vec<Phase>,
    pub boundaries: Vec<PhaseBoundary>,
}

/// Phases
#[derive(Debug, Clone)]
pub struct Phase {
    pub phase_id: String,
    pub phase_name: String,
    pub phase_type: PhaseType,
    pub composition: HashMap<String, f64>,
}

/// Phase types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PhaseType {
    Solid,
    Liquid,
    Gas,
    Plasma,
    Supercritical,
}

/// Phase boundaries
#[derive(Debug, Clone)]
pub struct PhaseBoundary {
    pub boundary_id: String,
    pub boundary_type: BoundaryType,
    pub conditions: Vec<BoundaryCondition>,
}

/// Phase boundary types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PhaseBoundaryType {
    Melting,
    Boiling,
    Sublimation,
    Triple,
    Critical,
}

/// Boundary conditions
#[derive(Debug, Clone)]
pub struct BoundaryCondition {
    pub temperature: f64,
    pub pressure: f64,
    pub composition: HashMap<String, f64>,
}

/// Phase transitions
#[derive(Debug, Clone)]
pub struct PhaseTransition {
    pub transition_id: String,
    pub transition_type: TransitionType,
    pub enthalpy_change: f64,
    pub entropy_change: f64,
}

/// Transition types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum TransitionType {
    Fusion,
    Vaporization,
    Sublimation,
    Deposition,
    Ionization,
}

/// Phase equilibria
#[derive(Debug, Clone)]
pub struct PhaseEquilibrium {
    pub equilibrium_id: String,
    pub phases: Vec<String>,
    pub equilibrium_conditions: EquilibriumConditions,
}

/// Equilibrium conditions
#[derive(Debug, Clone)]
pub struct EquilibriumConditions {
    pub temperature: f64,
    pub pressure: f64,
    pub chemical_potentials: HashMap<String, f64>,
}

impl ReactionAnalyzer {
    pub fn new() -> Self {
        Self {
            reaction_network: ReactionNetwork::new(),
            kinetics_calculator: KineticsCalculator::new(),
            thermodynamics_calculator: ThermodynamicsCalculator::new(),
        }
    }

    /// Borrow the reaction network.
    pub fn reaction_network(&self) -> &ReactionNetwork {
        &self.reaction_network
    }

    /// Mutably borrow the reaction network.
    pub fn reaction_network_mut(&mut self) -> &mut ReactionNetwork {
        &mut self.reaction_network
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        self.kinetics_calculator.initialize()?;
        self.thermodynamics_calculator.initialize()?;
        Ok(())
    }

    pub fn validate_reaction(&self, reaction: &Reaction) -> Result<(), ChemistryError> {
        if reaction.reactants.is_empty() {
            return Err(ChemistryError::ValidationError(
                "Reaction must have at least one reactant".to_string(),
            ));
        }
        if reaction.products.is_empty() {
            return Err(ChemistryError::ValidationError(
                "Reaction must have at least one product".to_string(),
            ));
        }
        Ok(())
    }

    pub fn analyze_kinetics(
        &mut self,
        reaction: &Reaction,
        conditions: &ReactionConditions,
    ) -> Result<KineticsResults, ChemistryError> {
        // REAL chemical kinetics via the Arrhenius equation:  k = A·exp(−Ea / (R·T)).
        // The mechanism's rate-determining step (highest activation energy) governs the overall
        // rate. `ReactionStep.rate_constant` is taken as the pre-exponential / frequency factor A
        // and `activation_energy` as Ea in kJ/mol. Half-life follows from the reaction order.
        const R: f64 = 8.314_462_618; // universal gas constant, J/(mol·K)

        let t = conditions.temperature; // Kelvin
        if !(t.is_finite() && t > 0.0) {
            return Err(ChemistryError::ValidationError(
                "temperature must be a positive value in Kelvin".to_string(),
            ));
        }

        // Rate-determining elementary step = the one with the highest activation barrier.
        let rds = reaction
            .mechanism
            .steps
            .iter()
            .max_by(|a, b| {
                a.activation_energy
                    .partial_cmp(&b.activation_energy)
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .ok_or_else(|| {
                ChemistryError::InsufficientData(
                    "reaction has no mechanism steps; cannot determine rate-determining step"
                        .to_string(),
                )
            })?;

        let a_factor = rds.rate_constant; // pre-exponential (frequency) factor A
        let ea_kj = rds.activation_energy; // kJ/mol
        if !(a_factor.is_finite() && ea_kj.is_finite()) {
            return Err(ChemistryError::ValidationError(
                "rate-determining step has non-finite A or Ea".to_string(),
            ));
        }
        let ea_j = ea_kj * 1000.0; // kJ/mol → J/mol
        let rate_constant = a_factor * (-ea_j / (R * t)).exp(); // k(T)

        // Overall order ≈ number of distinct reactant species (elementary-rate approximation).
        let reaction_order = reaction.reactants.len().max(1) as u32;

        // Initial concentration of the first reactant (for order-dependent half-life).
        let c0 = reaction
            .reactants
            .first()
            .and_then(|name| conditions.concentration.get(name).copied())
            .unwrap_or(1.0);

        // Half-life by integrated rate law.
        let half_life = if rate_constant <= 0.0 {
            f64::INFINITY
        } else {
            match reaction_order {
                0 => c0 / (2.0 * rate_constant), // t½ = [A]₀ / 2k
                2 => {
                    if c0 > 0.0 {
                        1.0 / (rate_constant * c0)
                    } else {
                        f64::INFINITY
                    }
                } // 1 / (k[A]₀)
                _ => std::f64::consts::LN_2 / rate_constant, // first order: ln2 / k
            }
        };

        Ok(KineticsResults {
            rate_constant,
            activation_energy: ea_kj,
            reaction_order,
            half_life,
        })
    }
}

impl ReactionNetwork {
    pub fn new() -> Self {
        Self {
            reactions: HashMap::new(),
            species: HashMap::new(),
            pathways: Vec::new(),
        }
    }

    /// Register a reaction under its `reaction_id`, replacing any existing entry.
    pub fn add_reaction(&mut self, reaction: Reaction) {
        self.reactions
            .insert(reaction.reaction_id.clone(), reaction);
    }

    /// Look up a reaction by id.
    pub fn get_reaction(&self, reaction_id: &str) -> Option<&Reaction> {
        self.reactions.get(reaction_id)
    }

    /// List the ids of all registered reactions.
    pub fn list_reactions(&self) -> Vec<String> {
        self.reactions.keys().cloned().collect()
    }

    /// Remove a reaction by id.
    pub fn remove_reaction(&mut self, reaction_id: &str) -> Option<Reaction> {
        self.reactions.remove(reaction_id)
    }

    /// Register a species under its `species_id`, replacing any existing entry.
    pub fn add_species(&mut self, species: Species) {
        self.species.insert(species.species_id.clone(), species);
    }

    /// Look up a species by id.
    pub fn get_species(&self, species_id: &str) -> Option<&Species> {
        self.species.get(species_id)
    }

    /// List the ids of all registered species.
    pub fn list_species(&self) -> Vec<String> {
        self.species.keys().cloned().collect()
    }

    /// Remove a species by id.
    pub fn remove_species(&mut self, species_id: &str) -> Option<Species> {
        self.species.remove(species_id)
    }

    /// Append a reaction pathway.
    pub fn add_pathway(&mut self, pathway: ReactionPathway) {
        self.pathways.push(pathway);
    }

    /// Borrow the reaction pathways.
    pub fn pathways(&self) -> &Vec<ReactionPathway> {
        &self.pathways
    }

    /// Mutably borrow the reaction pathways.
    pub fn pathways_mut(&mut self) -> &mut Vec<ReactionPathway> {
        &mut self.pathways
    }
}

impl Reaction {
    pub fn new() -> Self {
        Self {
            reaction_id: "rxn_1".to_string(),
            reaction_name: "Test reaction".to_string(),
            reactants: vec!["A".to_string()],
            products: vec!["B".to_string()],
            reaction_type: ReactionType::Elementary,
            mechanism: ReactionMechanism::new(),
        }
    }
}

impl ReactionMechanism {
    pub fn new() -> Self {
        Self {
            mechanism_id: "mech_1".to_string(),
            steps: vec![ReactionStep::new()],
            intermediates: Vec::new(),
        }
    }
}

impl ReactionStep {
    pub fn new() -> Self {
        Self {
            step_id: "step_1".to_string(),
            reactants: vec!["A".to_string()],
            products: vec!["B".to_string()],
            rate_constant: 1.0,
            activation_energy: 10.0,
        }
    }
}

impl Species {
    pub fn new() -> Self {
        Self {
            species_id: "species_1".to_string(),
            species_name: "Test species".to_string(),
            formula: "CH4".to_string(),
            molecular_weight: 16.04,
            properties: SpeciesProperties::new(),
        }
    }
}

impl SpeciesProperties {
    pub fn new() -> Self {
        Self {
            enthalpy: -74.8,
            entropy: 186.3,
            gibbs_free_energy: -50.8,
            heat_capacity: 35.7,
        }
    }
}

impl ReactionPathway {
    pub fn new() -> Self {
        Self {
            pathway_id: "pathway_1".to_string(),
            pathway_name: "Test pathway".to_string(),
            reactions: vec!["rxn_1".to_string()],
            branching_ratios: vec![1.0],
        }
    }
}

impl KineticsCalculator {
    pub fn new() -> Self {
        Self {
            rate_laws: HashMap::new(),
            rate_constants: HashMap::new(),
            reaction_rates: HashMap::new(),
        }
    }

    /// Register a rate law under its `law_id`, replacing any existing entry.
    pub fn add_rate_law(&mut self, law: RateLaw) {
        self.rate_laws.insert(law.law_id.clone(), law);
    }

    /// Look up a rate law by id.
    pub fn get_rate_law(&self, law_id: &str) -> Option<&RateLaw> {
        self.rate_laws.get(law_id)
    }

    /// List the ids of all registered rate laws.
    pub fn list_rate_laws(&self) -> Vec<String> {
        self.rate_laws.keys().cloned().collect()
    }

    /// Register a rate constant under its `constant_id`, replacing any existing entry.
    pub fn add_rate_constant(&mut self, constant: RateConstant) {
        self.rate_constants
            .insert(constant.constant_id.clone(), constant);
    }

    /// Look up a rate constant by id.
    pub fn get_rate_constant(&self, constant_id: &str) -> Option<&RateConstant> {
        self.rate_constants.get(constant_id)
    }

    /// List the ids of all registered rate constants.
    pub fn list_rate_constants(&self) -> Vec<String> {
        self.rate_constants.keys().cloned().collect()
    }

    /// Record the instantaneous rate for a reaction id.
    pub fn set_reaction_rate(&mut self, reaction_id: &str, rate: f64) {
        self.reaction_rates.insert(reaction_id.to_string(), rate);
    }

    /// Look up the recorded rate for a reaction id.
    pub fn get_reaction_rate(&self, reaction_id: &str) -> Option<&f64> {
        self.reaction_rates.get(reaction_id)
    }

    /// List the reaction ids that have a recorded rate.
    pub fn list_reaction_rates(&self) -> Vec<String> {
        self.reaction_rates.keys().cloned().collect()
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        Ok(())
    }
}

impl RateLaw {
    pub fn new() -> Self {
        Self {
            law_id: "law_1".to_string(),
            law_type: RateLawType::Elementary,
            rate_expression: "k * [A]".to_string(),
            parameters: RateLawParameters::new(),
        }
    }
}

impl RateLawParameters {
    pub fn new() -> Self {
        Self {
            rate_constant: 1.0,
            reaction_orders: vec![1.0],
            saturation_constants: Vec::new(),
        }
    }
}

impl RateConstant {
    pub fn new() -> Self {
        Self {
            constant_id: "const_1".to_string(),
            value: 1.0,
            temperature_dependence: TemperatureDependence::new(),
            pressure_dependence: PressureDependence::new(),
        }
    }
}

impl TemperatureDependence {
    pub fn new() -> Self {
        Self {
            arrhenius_parameters: ArrheniusParameters::new(),
            modified_arrhenius: None,
        }
    }
}

impl ArrheniusParameters {
    pub fn new() -> Self {
        Self {
            pre_exponential: 1.0e13,
            activation_energy: 10000.0,
        }
    }
}

impl ModifiedArrheniusParameters {
    pub fn new() -> Self {
        Self {
            pre_exponential: 1.0e13,
            activation_energy: 10000.0,
            temperature_exponent: 0.0,
        }
    }
}

impl PressureDependence {
    pub fn new() -> Self {
        Self {
            fall_off_parameters: FallOffParameters::new(),
            third_body_efficiency: 1.0,
        }
    }
}

impl FallOffParameters {
    pub fn new() -> Self {
        Self {
            low_pressure_limit: 1.0,
            high_pressure_limit: 1.0,
            fall_off_exponent: 1.0,
        }
    }
}

impl ThermodynamicsCalculator {
    pub fn new() -> Self {
        Self {
            thermodynamic_data: HashMap::new(),
            equilibrium_calculator: EquilibriumCalculator::new(),
            phase_calculator: PhaseCalculator::new(),
        }
    }

    /// Register thermodynamic data under its `data_id`, replacing any existing entry.
    pub fn add_thermodynamic_data(&mut self, data: ThermodynamicData) {
        self.thermodynamic_data.insert(data.data_id.clone(), data);
    }

    /// Look up thermodynamic data by id.
    pub fn get_thermodynamic_data(&self, data_id: &str) -> Option<&ThermodynamicData> {
        self.thermodynamic_data.get(data_id)
    }

    /// List the ids of all registered thermodynamic data entries.
    pub fn list_thermodynamic_data(&self) -> Vec<String> {
        self.thermodynamic_data.keys().cloned().collect()
    }

    /// Remove thermodynamic data by id.
    pub fn remove_thermodynamic_data(&mut self, data_id: &str) -> Option<ThermodynamicData> {
        self.thermodynamic_data.remove(data_id)
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        self.equilibrium_calculator.initialize()?;
        self.phase_calculator.initialize()?;
        Ok(())
    }
}

impl ThermodynamicData {
    pub fn new() -> Self {
        Self {
            data_id: "data_1".to_string(),
            temperature_range: (200.0, 400.0),
            enthalpy: -74.8,
            entropy: 186.3,
            gibbs_free_energy: -50.8,
            heat_capacity: 35.7,
        }
    }
}

impl EquilibriumCalculator {
    pub fn new() -> Self {
        Self {
            equilibrium_constant: EquilibriumConstant::new(),
            reaction_quotient: ReactionQuotient::new(),
            gibbs_energy: GibbsEnergy::new(),
        }
    }

    /// Borrow the equilibrium constant.
    pub fn equilibrium_constant(&self) -> &EquilibriumConstant {
        &self.equilibrium_constant
    }

    /// Mutably borrow the equilibrium constant.
    pub fn equilibrium_constant_mut(&mut self) -> &mut EquilibriumConstant {
        &mut self.equilibrium_constant
    }

    /// Borrow the reaction quotient.
    pub fn reaction_quotient(&self) -> &ReactionQuotient {
        &self.reaction_quotient
    }

    /// Mutably borrow the reaction quotient.
    pub fn reaction_quotient_mut(&mut self) -> &mut ReactionQuotient {
        &mut self.reaction_quotient
    }

    /// Borrow the Gibbs energy.
    pub fn gibbs_energy(&self) -> &GibbsEnergy {
        &self.gibbs_energy
    }

    /// Mutably borrow the Gibbs energy.
    pub fn gibbs_energy_mut(&mut self) -> &mut GibbsEnergy {
        &mut self.gibbs_energy
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        Ok(())
    }
}

impl EquilibriumConstant {
    pub fn new() -> Self {
        Self {
            value: 1.0,
            temperature: 298.15,
            pressure: 1.0,
        }
    }
}

impl ReactionQuotient {
    pub fn new() -> Self {
        Self {
            value: 1.0,
            concentrations: HashMap::new(),
        }
    }
}

impl GibbsEnergy {
    pub fn new() -> Self {
        Self {
            standard_gibbs: -50.8,
            actual_gibbs: -50.8,
            delta_g: 0.0,
        }
    }
}

impl PhaseCalculator {
    pub fn new() -> Self {
        Self {
            phase_diagrams: HashMap::new(),
            phase_transitions: HashMap::new(),
            phase_equilibria: HashMap::new(),
        }
    }

    /// Register a phase diagram under its `diagram_id`, replacing any existing entry.
    pub fn add_phase_diagram(&mut self, diagram: PhaseDiagram) {
        self.phase_diagrams
            .insert(diagram.diagram_id.clone(), diagram);
    }

    /// Look up a phase diagram by id.
    pub fn get_phase_diagram(&self, diagram_id: &str) -> Option<&PhaseDiagram> {
        self.phase_diagrams.get(diagram_id)
    }

    /// List the ids of all registered phase diagrams.
    pub fn list_phase_diagrams(&self) -> Vec<String> {
        self.phase_diagrams.keys().cloned().collect()
    }

    /// Register a phase transition under its `transition_id`, replacing any existing entry.
    pub fn add_phase_transition(&mut self, transition: PhaseTransition) {
        self.phase_transitions
            .insert(transition.transition_id.clone(), transition);
    }

    /// Look up a phase transition by id.
    pub fn get_phase_transition(&self, transition_id: &str) -> Option<&PhaseTransition> {
        self.phase_transitions.get(transition_id)
    }

    /// List the ids of all registered phase transitions.
    pub fn list_phase_transitions(&self) -> Vec<String> {
        self.phase_transitions.keys().cloned().collect()
    }

    /// Register a phase equilibrium under its `equilibrium_id`, replacing any existing entry.
    pub fn add_phase_equilibrium(&mut self, equilibrium: PhaseEquilibrium) {
        self.phase_equilibria
            .insert(equilibrium.equilibrium_id.clone(), equilibrium);
    }

    /// Look up a phase equilibrium by id.
    pub fn get_phase_equilibrium(&self, equilibrium_id: &str) -> Option<&PhaseEquilibrium> {
        self.phase_equilibria.get(equilibrium_id)
    }

    /// List the ids of all registered phase equilibria.
    pub fn list_phase_equilibria(&self) -> Vec<String> {
        self.phase_equilibria.keys().cloned().collect()
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        Ok(())
    }
}

impl PhaseDiagram {
    pub fn new() -> Self {
        Self {
            diagram_id: "diagram_1".to_string(),
            phases: vec![Phase::new()],
            boundaries: Vec::new(),
        }
    }
}

impl Phase {
    pub fn new() -> Self {
        Self {
            phase_id: "phase_1".to_string(),
            phase_name: "Liquid".to_string(),
            phase_type: PhaseType::Liquid,
            composition: HashMap::new(),
        }
    }
}

impl PhaseBoundary {
    pub fn new() -> Self {
        Self {
            boundary_id: "boundary_1".to_string(),
            boundary_type: BoundaryType::Boiling,
            conditions: vec![BoundaryCondition::new()],
        }
    }
}

impl BoundaryCondition {
    pub fn new() -> Self {
        Self {
            temperature: 373.15,
            pressure: 1.0,
            composition: HashMap::new(),
        }
    }
}

impl PhaseTransition {
    pub fn new() -> Self {
        Self {
            transition_id: "transition_1".to_string(),
            transition_type: TransitionType::Fusion,
            enthalpy_change: 6.01,
            entropy_change: 22.0,
        }
    }
}

impl PhaseEquilibrium {
    pub fn new() -> Self {
        Self {
            equilibrium_id: "eq_1".to_string(),
            phases: vec!["phase_1".to_string()],
            equilibrium_conditions: EquilibriumConditions::new(),
        }
    }
}

impl EquilibriumConditions {
    pub fn new() -> Self {
        Self {
            temperature: 273.15,
            pressure: 1.0,
            chemical_potentials: HashMap::new(),
        }
    }
}