qualia_core_db/specialized_libs/chemistry_modeling/

properties.rs

use super::*;

/// Property predictor for molecular property prediction
pub struct PropertyPredictor {
    property_models: HashMap<String, PropertyModel>,
    descriptor_calculator: DescriptorCalculator,
    machine_learning_models: HashMap<String, MLModel>,
}

/// Property models
#[derive(Debug, Clone)]
pub struct PropertyModel {
    pub model_id: String,
    pub property_type: PropertyType,
    pub model_type: PropertyModelType,
    pub parameters: PropertyModelParameters,
}

/// Property types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PropertyType {
    BoilingPoint,
    MeltingPoint,
    Density,
    Viscosity,
    SurfaceTension,
    HeatCapacity,
    ThermalConductivity,
    ElectricalConductivity,
    OpticalProperties,
    MagneticProperties,
}

/// Property model types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PropertyModelType {
    GroupContribution,
    QSPR,
    MachineLearning,
    MolecularDynamics,
    QuantumMechanical,
}

/// Property model parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PropertyModelParameters {
    pub coefficients: HashMap<String, f64>,
    pub descriptors: Vec<String>,
    pub reference_data: Vec<ReferenceData>,
}

/// Reference data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReferenceData {
    pub molecule_id: String,
    pub property_value: f64,
    pub conditions: ReferenceConditions,
}

/// Reference conditions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReferenceConditions {
    pub temperature: f64,
    pub pressure: f64,
    pub phase: PhaseType,
}

/// Descriptor calculator
pub struct DescriptorCalculator {
    molecular_descriptors: MolecularDescriptors,
    quantum_descriptors: QuantumDescriptors,
    topological_descriptors: TopologicalDescriptors,
}

/// Molecular descriptors
#[derive(Debug, Clone)]
pub struct MolecularDescriptors {
    pub molecular_weight: f64,
    pub formula: String,
    pub atom_count: HashMap<String, usize>,
    pub bond_count: HashMap<String, usize>,
    pub ring_count: usize,
}

/// Quantum descriptors
#[derive(Debug, Clone)]
pub struct QuantumDescriptors {
    pub homo_energy: f64,
    pub lumo_energy: f64,
    pub gap: f64,
    pub dipole_moment: f64,
    pub polarizability: f64,
}

/// Topological descriptors
#[derive(Debug, Clone)]
pub struct TopologicalDescriptors {
    pub connectivity_index: f64,
    pub shape_index: f64,
    pub wiener_index: f64,
    pub randic_index: f64,
}

/// Machine learning models
#[derive(Debug, Clone)]
pub struct MLModel {
    pub model_id: String,
    pub model_type: MLModelType,
    pub model_parameters: MLModelParameters,
    pub training_data: TrainingData,
}

/// ML model types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MLModelType {
    LinearRegression,
    RandomForest,
    NeuralNetwork,
    SupportVector,
    GaussianProcess,
}

/// ML model parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MLModelParameters {
    pub hyperparameters: HashMap<String, f64>,
    pub feature_importance: HashMap<String, f64>,
    pub model_performance: ModelPerformance,
}

/// Model performance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelPerformance {
    pub r_squared: f64,
    pub rmse: f64,
    pub mae: f64,
    pub cross_validation_score: f64,
}

/// Training data
#[derive(Debug, Clone)]
pub struct TrainingData {
    pub data_id: String,
    pub features: Vec<Vec<f64>>,
    pub targets: Vec<f64>,
    pub data_size: usize,
}

impl PropertyPredictor {
    pub fn new() -> Self {
        Self {
            property_models: HashMap::new(),
            descriptor_calculator: DescriptorCalculator::new(),
            machine_learning_models: HashMap::new(),
        }
    }

    pub fn initialize(&mut self) -> Result<(), ChemistryError> {
        self.descriptor_calculator.initialize()?;
        // Register basic QSPR / group-contribution models for common properties.
        // Each model stores its coefficients in `parameters.coefficients`: the
        // special key `"intercept"` is added directly, every other key names a
        // molecular descriptor whose value is multiplied by its coefficient
        // (group-contribution form: predicted = Σ c_i·d_i + intercept).
        self.register_standard_qspr_models();
        Ok(())
    }

    /// Register the built-in QSPR property models.
    fn register_standard_qspr_models(&mut self) {
        // Boiling point — simple Joback-style group contribution:
        //   Tb = 198.2 + Σ(group contributions)
        self.register_model(
            "boiling_point",
            PropertyModel {
                model_id: "qspr_boiling_point".to_string(),
                property_type: PropertyType::BoilingPoint,
                model_type: PropertyModelType::GroupContribution,
                parameters: PropertyModelParameters {
                    coefficients: {
                        let mut c = HashMap::new();
                        c.insert("intercept".to_string(), 198.2);
                        c.insert("C".to_string(), 23.97);
                        c.insert("H".to_string(), 22.88);
                        c.insert("O".to_string(), 10.0);
                        c.insert("N".to_string(), 5.0);
                        c.insert("ring".to_string(), -50.0);
                        c
                    },
                    descriptors: vec![
                        "C".to_string(),
                        "H".to_string(),
                        "O".to_string(),
                        "N".to_string(),
                        "ring".to_string(),
                    ],
                    reference_data: Vec::new(),
                },
            },
        );

        // Melting point — Joback-style group contribution:
        //   Tm = 122.5 + Σ(group contributions)
        self.register_model(
            "melting_point",
            PropertyModel {
                model_id: "qspr_melting_point".to_string(),
                property_type: PropertyType::MeltingPoint,
                model_type: PropertyModelType::GroupContribution,
                parameters: PropertyModelParameters {
                    coefficients: {
                        let mut c = HashMap::new();
                        c.insert("intercept".to_string(), 122.5);
                        c.insert("C".to_string(), -5.51);
                        c.insert("H".to_string(), 8.45);
                        c.insert("O".to_string(), 4.0);
                        c.insert("N".to_string(), 2.5);
                        c.insert("ring".to_string(), -20.0);
                        c
                    },
                    descriptors: vec![
                        "C".to_string(),
                        "H".to_string(),
                        "O".to_string(),
                        "N".to_string(),
                        "ring".to_string(),
                    ],
                    reference_data: Vec::new(),
                },
            },
        );

        // Solubility — general solubility equation approximation:
        //   logS = -0.5·logP - 0.01·MW + 0.5
        self.register_model(
            "solubility",
            PropertyModel {
                model_id: "qspr_solubility".to_string(),
                property_type: PropertyType::Density, // no dedicated Solubility variant; closest physical property
                model_type: PropertyModelType::GroupContribution,
                parameters: PropertyModelParameters {
                    coefficients: {
                        let mut c = HashMap::new();
                        c.insert("intercept".to_string(), 0.5);
                        c.insert("logP".to_string(), -0.5);
                        c.insert("molecular_weight".to_string(), -0.01);
                        c
                    },
                    descriptors: vec!["logP".to_string(), "molecular_weight".to_string()],
                    reference_data: Vec::new(),
                },
            },
        );

        // Molecular weight — atom-count model:
        //   MW = Σ(atom_count · atomic_weight)
        self.register_model(
            "molecular_weight",
            PropertyModel {
                model_id: "qspr_molecular_weight".to_string(),
                property_type: PropertyType::Density, // no dedicated MolecularWeight variant
                model_type: PropertyModelType::GroupContribution,
                parameters: PropertyModelParameters {
                    coefficients: {
                        let mut c = HashMap::new();
                        c.insert("intercept".to_string(), 0.0);
                        c.insert("C".to_string(), 12.011);
                        c.insert("H".to_string(), 1.008);
                        c.insert("O".to_string(), 15.999);
                        c.insert("N".to_string(), 14.007);
                        c.insert("S".to_string(), 32.06);
                        c.insert("Cl".to_string(), 35.45);
                        c
                    },
                    descriptors: vec![
                        "C".to_string(),
                        "H".to_string(),
                        "O".to_string(),
                        "N".to_string(),
                        "S".to_string(),
                        "Cl".to_string(),
                    ],
                    reference_data: Vec::new(),
                },
            },
        );
    }

    pub fn validate_molecule(&self, molecule: &Molecule) -> Result<(), ChemistryError> {
        if molecule.atoms.is_empty() {
            return Err(ChemistryError::ValidationError(
                "Molecule must have at least one atom".to_string(),
            ));
        }
        Ok(())
    }

    /// Predict a molecular property using the registered QSPR models.
    ///
    /// Applies the group-contribution formula
    /// `predicted = Σ(coefficient_i · descriptor_i) + intercept`, where the
    /// special coefficient key `"intercept"` is added directly and every other
    /// key names a descriptor in `molecular_descriptors` (missing descriptors
    /// contribute zero). Returns [`ChemistryError::NotImplemented`] when no
    /// model is registered for `property_name`.
    pub fn predict(
        &self,
        property_name: &str,
        molecular_descriptors: &HashMap<String, f64>,
    ) -> Result<f64, ChemistryError> {
        let model = self.property_models.get(property_name).ok_or_else(|| {
            ChemistryError::NotImplemented(format!(
                "no QSPR model registered for property '{}'",
                property_name
            ))
        })?;

        let mut predicted = 0.0;
        for (descriptor, coefficient) in &model.parameters.coefficients {
            if descriptor == "intercept" {
                predicted += coefficient;
            } else {
                let value = molecular_descriptors
                    .get(descriptor)
                    .copied()
                    .unwrap_or(0.0);
                predicted += coefficient * value;
            }
        }
        Ok(predicted)
    }

    /// Predict properties for a concrete molecule. Computes molecular
    /// descriptors (molecular weight, per-element atom counts, logP defaulting
    /// to 0.0 when unknown) from the molecule and dispatches to
    /// [`predict`](Self::predict) for each requested property type that has a
    /// registered model. Returns `NotImplemented` if none of the requested
    /// property types have a model.
    pub fn predict_from_molecule(
        &self,
        molecule: &Molecule,
        properties: &[PropertyType],
    ) -> Result<PredictedProperties, ChemistryError> {
        // Compute molecular descriptors from the molecule.
        let mut descriptors: HashMap<String, f64> = HashMap::new();
        let mut molecular_weight = 0.0;
        let mut atom_counts: HashMap<String, f64> = HashMap::new();
        for atom in &molecule.atoms {
            molecular_weight += atom.mass;
            *atom_counts.entry(atom.element.clone()).or_insert(0.0) += 1.0;
        }
        descriptors.insert("molecular_weight".to_string(), molecular_weight);
        for (element, count) in &atom_counts {
            descriptors.insert(element.clone(), *count);
        }
        // logP is not derivable from the atom list alone here; default to 0.0
        // (unknown) so the solubility model degrades gracefully.
        descriptors.insert("logP".to_string(), 0.0);

        let mut result = PredictedProperties::new();
        for property_type in properties {
            let name = match property_type {
                PropertyType::BoilingPoint => "boiling_point",
                PropertyType::MeltingPoint => "melting_point",
                // No registered QSPR model for the remaining property types.
                _ => continue,
            };
            match self.predict(name, &descriptors) {
                Ok(value) => {
                    result.properties.insert(name.to_string(), value);
                }
                Err(ChemistryError::NotImplemented(_)) => continue,
                Err(e) => return Err(e),
            }
        }

        if result.properties.is_empty() {
            return Err(ChemistryError::NotImplemented(
                "no QSPR models available for the requested property types".to_string(),
            ));
        }
        Ok(result)
    }

    /// Register a custom property model under `name`, replacing any existing
    /// entry.
    pub fn register_model(&mut self, name: &str, model: PropertyModel) {
        self.property_models.insert(name.to_string(), model);
    }

    /// List the names of all registered property models.
    pub fn list_properties(&self) -> Vec<String> {
        self.property_models.keys().cloned().collect()
    }

    /// Register a machine-learning model under its `model_id`, replacing any
    /// existing entry.
    pub fn register_ml_model(&mut self, model: MLModel) {
        self.machine_learning_models
            .insert(model.model_id.clone(), model);
    }

    /// Look up a machine-learning model by id.
    pub fn get_ml_model(&self, model_id: &str) -> Option<&MLModel> {
        self.machine_learning_models.get(model_id)
    }

    /// Mutably borrow a machine-learning model by id.
    pub fn get_ml_model_mut(&mut self, model_id: &str) -> Option<&mut MLModel> {
        self.machine_learning_models.get_mut(model_id)
    }

    /// List the ids of all registered machine-learning models.
    pub fn list_ml_models(&self) -> Vec<String> {
        self.machine_learning_models.keys().cloned().collect()
    }

    /// Remove a machine-learning model by id.
    pub fn remove_ml_model(&mut self, model_id: &str) -> Option<MLModel> {
        self.machine_learning_models.remove(model_id)
    }
}

impl PropertyModel {
    pub fn new() -> Self {
        Self {
            model_id: "model_1".to_string(),
            property_type: PropertyType::BoilingPoint,
            model_type: PropertyModelType::GroupContribution,
            parameters: PropertyModelParameters::new(),
        }
    }
}

impl PropertyModelParameters {
    pub fn new() -> Self {
        Self {
            coefficients: HashMap::new(),
            descriptors: vec!["molecular_weight".to_string()],
            reference_data: vec![ReferenceData::new()],
        }
    }
}

impl ReferenceData {
    pub fn new() -> Self {
        Self {
            molecule_id: "mol_1".to_string(),
            property_value: 100.0,
            conditions: ReferenceConditions::new(),
        }
    }
}

impl ReferenceConditions {
    pub fn new() -> Self {
        Self {
            temperature: 298.15,
            pressure: 1.0,
            phase: PhaseType::Liquid,
        }
    }
}

impl DescriptorCalculator {
    pub fn new() -> Self {
        Self {
            molecular_descriptors: MolecularDescriptors::new(),
            quantum_descriptors: QuantumDescriptors::new(),
            topological_descriptors: TopologicalDescriptors::new(),
        }
    }

    /// Borrow the molecular descriptors.
    pub fn molecular_descriptors(&self) -> &MolecularDescriptors {
        &self.molecular_descriptors
    }

    /// Mutably borrow the molecular descriptors.
    pub fn molecular_descriptors_mut(&mut self) -> &mut MolecularDescriptors {
        &mut self.molecular_descriptors
    }

    /// Borrow the quantum descriptors.
    pub fn quantum_descriptors(&self) -> &QuantumDescriptors {
        &self.quantum_descriptors
    }

    /// Mutably borrow the quantum descriptors.
    pub fn quantum_descriptors_mut(&mut self) -> &mut QuantumDescriptors {
        &mut self.quantum_descriptors
    }

    /// Borrow the topological descriptors.
    pub fn topological_descriptors(&self) -> &TopologicalDescriptors {
        &self.topological_descriptors
    }

    /// Mutably borrow the topological descriptors.
    pub fn topological_descriptors_mut(&mut self) -> &mut TopologicalDescriptors {
        &mut self.topological_descriptors
    }

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

impl MolecularDescriptors {
    pub fn new() -> Self {
        Self {
            molecular_weight: 16.04,
            formula: "CH4".to_string(),
            atom_count: HashMap::new(),
            bond_count: HashMap::new(),
            ring_count: 0,
        }
    }
}

impl QuantumDescriptors {
    pub fn new() -> Self {
        Self {
            homo_energy: -13.6,
            lumo_energy: 0.0,
            gap: 13.6,
            dipole_moment: 0.0,
            polarizability: 0.0,
        }
    }
}

impl TopologicalDescriptors {
    pub fn new() -> Self {
        Self {
            connectivity_index: 1.0,
            shape_index: 1.0,
            wiener_index: 1.0,
            randic_index: 1.0,
        }
    }
}

impl MLModel {
    pub fn new() -> Self {
        Self {
            model_id: "ml_1".to_string(),
            model_type: MLModelType::LinearRegression,
            model_parameters: MLModelParameters::new(),
            training_data: TrainingData::new(),
        }
    }
}

impl MLModelParameters {
    pub fn new() -> Self {
        Self {
            hyperparameters: HashMap::new(),
            feature_importance: HashMap::new(),
            model_performance: ModelPerformance::new(),
        }
    }
}

impl ModelPerformance {
    pub fn new() -> Self {
        Self {
            r_squared: 0.95,
            rmse: 0.1,
            mae: 0.08,
            cross_validation_score: 0.0, // not measured (scaffold default; no validation performed)
        }
    }
}

impl TrainingData {
    pub fn new() -> Self {
        Self {
            data_id: "data_1".to_string(),
            features: vec![vec![1.0; 10]; 100],
            targets: vec![100.0; 100],
            data_size: 100,
        }
    }
}