use std::collections::HashMap;
use molar::prelude::*;
mod gaff;
#[cfg(feature = "espaloma")]
pub mod charge;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FFType {
Gaff,
Gaff2,
}
#[derive(Debug, thiserror::Error)]
pub enum FFError {
#[error(
"bond {0}-{1} has no known order; force-field typing requires known bond \
orders (use an SDF/mol2 input)"
)]
MissingBondOrders(usize, usize),
#[error(
"selection is not bond-complete: atom {global} is bonded to non-selected \
atom {neighbor}"
)]
OpenSelection { global: usize, neighbor: usize },
#[error("could not assign a {ff:?} atom type to atom {local} (element Z={z})")]
UntypedAtom { ff: FFType, local: usize, z: u8 },
}
pub trait ApplyFF {
fn apply_ff(&mut self, ff: FFType) -> Result<(), FFError>;
}
impl<T: AtomMutProvider + BondProvider> ApplyFF for T {
fn apply_ff(&mut self, ff: FFType) -> Result<(), FFError> {
let global: Vec<usize> = self.iter_index().collect();
let g2l: HashMap<usize, usize> =
global.iter().enumerate().map(|(l, &g)| (g, l)).collect();
let z: Vec<u8> = self.iter_atoms().map(|a| a.get_atomic_number()).collect();
let mut bonds: Vec<gaff::LocalBond> = Vec::new();
for b in self.iter_bonds() {
match (g2l.get(&b.i1).copied(), g2l.get(&b.i2).copied()) {
(Some(i), Some(j)) => {
let order = bond_order_code(b.order)
.ok_or(FFError::MissingBondOrders(b.i1, b.i2))?;
bonds.push(gaff::LocalBond { i, j, order });
}
(Some(_), None) => {
return Err(FFError::OpenSelection { global: b.i1, neighbor: b.i2 })
}
(None, Some(_)) => {
return Err(FFError::OpenSelection { global: b.i2, neighbor: b.i1 })
}
(None, None) => {} }
}
let types = gaff::gaff_types(&z, &bonds, ff)?;
for (mut a, t) in self.iter_atoms_mut().zip(types) {
a.set_type_name(&t);
}
Ok(())
}
}
fn bond_order_code(o: BondOrder) -> Option<u8> {
match o {
BondOrder::Single => Some(1),
BondOrder::Double => Some(2),
BondOrder::Triple => Some(3),
BondOrder::Aromatic => Some(4),
BondOrder::Unspecified => None,
}
}
#[cfg(feature = "espaloma")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChargeModel {
Espaloma,
}
#[cfg(feature = "espaloma")]
#[derive(Debug, thiserror::Error)]
pub enum ChargeError {
#[error(
"bond {0}-{1} has no explicit Kekulé order; charge prediction requires single/double/\
triple bonds (use an SDF/mol2 input)"
)]
MissingBondOrders(usize, usize),
#[error(
"selection is not bond-complete: atom {global} is bonded to non-selected atom {neighbor}"
)]
OpenSelection { global: usize, neighbor: usize },
#[error("element Z={0} is not supported by the {1:?} charge model")]
UnsupportedElement(u8, ChargeModel),
#[error("charge model inference failed: {0}")]
Inference(String),
}
#[cfg(feature = "espaloma")]
pub trait ApplyCharges {
fn apply_charges(&mut self, model: ChargeModel) -> Result<(), ChargeError>;
}
#[cfg(feature = "espaloma")]
impl<T: AtomMutProvider + BondProvider> ApplyCharges for T {
fn apply_charges(&mut self, model: ChargeModel) -> Result<(), ChargeError> {
match model {
ChargeModel::Espaloma => {}
}
let global: Vec<usize> = self.iter_index().collect();
let g2l: HashMap<usize, usize> =
global.iter().enumerate().map(|(l, &g)| (g, l)).collect();
let z: Vec<u8> = self.iter_atoms().map(|a| a.get_atomic_number()).collect();
if let Some(&bad) = z.iter().find(|&&zi| {
!matches!(zi, 1 | 6 | 7 | 8 | 9 | 15 | 16 | 17 | 35 | 53)
}) {
return Err(ChargeError::UnsupportedElement(bad, model));
}
let fc: Vec<i32> = self.iter_atoms().map(|a| a.get_formal_charge().unwrap_or(0)).collect();
let mut bonds: Vec<gaff::LocalBond> = Vec::new();
for b in self.iter_bonds() {
match (g2l.get(&b.i1).copied(), g2l.get(&b.i2).copied()) {
(Some(i), Some(j)) => {
let order = match b.order {
BondOrder::Single => 1,
BondOrder::Double => 2,
BondOrder::Triple => 3,
_ => return Err(ChargeError::MissingBondOrders(b.i1, b.i2)),
};
bonds.push(gaff::LocalBond { i, j, order });
}
(Some(_), None) => {
return Err(ChargeError::OpenSelection { global: b.i1, neighbor: b.i2 })
}
(None, Some(_)) => {
return Err(ChargeError::OpenSelection { global: b.i2, neighbor: b.i1 })
}
(None, None) => {}
}
}
let q = charge::espaloma_charges(&z, &fc, &bonds)
.map_err(|e| ChargeError::Inference(e.to_string()))?;
for (mut a, c) in self.iter_atoms_mut().zip(q) {
a.set_charge(c as Float);
}
Ok(())
}
}