use std::collections::HashMap;
use molar::prelude::*;
mod gaff;
mod prepare;
pub mod charge;
pub mod amber;
pub use prepare::{PrepareForFF, PrepareOptions};
#[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(transparent)]
InvalidAromatic(molar::KekulizeError),
#[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();
let mut orders: Vec<BondOrder> = Vec::new();
for b in self.iter_bonds() {
let ([g1, g2], b_order) = (b.pair(), b.order());
match (g2l.get(&g1).copied(), g2l.get(&g2).copied()) {
(Some(i), Some(j)) => {
let order =
bond_order_code(b_order).ok_or(FFError::MissingBondOrders(g1, g2))?;
bonds.push(gaff::LocalBond { i, j, order });
orders.push(b_order);
}
(Some(_), None) => {
return Err(FFError::OpenSelection { global: g1, neighbor: g2 })
}
(None, Some(_)) => {
return Err(FFError::OpenSelection { global: g2, neighbor: g1 })
}
(None, None) => {} }
}
if orders.contains(&BondOrder::Aromatic) {
let adj = BondAdjacency::build(z.len(), bonds.iter().map(|b| [b.i, b.j]));
let fc: Vec<i32> = self
.iter_atoms()
.map(|a| a.get_formal_charge().unwrap_or(0))
.collect();
match kekulize(&z, &fc, &orders, &adj) {
Err(
e @ (molar::KekulizeError::NonKekulizable(_)
| molar::KekulizeError::OverValent(_)),
) => {
return Err(FFError::InvalidAromatic(e.remap_atoms(&global)));
}
_ => {}
}
}
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,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChargeModel {
Espaloma,
}
#[derive(Debug, thiserror::Error)]
pub enum ChargeError {
#[error(
"bond {0}-{1} has no known order; charge prediction requires real bond orders \
(use an SDF/mol2 input)"
)]
MissingBondOrders(usize, usize),
#[error(transparent)]
Kekulize(#[from] molar::KekulizeError),
#[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),
}
pub trait ApplyCharges {
fn apply_charges(&mut self, model: ChargeModel) -> Result<(), ChargeError>;
}
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 pairs: Vec<[usize; 2]> = Vec::new();
let mut orders: Vec<BondOrder> = Vec::new();
for b in self.iter_bonds() {
let ([g1, g2], b_order) = (b.pair(), b.order());
match (g2l.get(&g1).copied(), g2l.get(&g2).copied()) {
(Some(i), Some(j)) => {
if b_order == BondOrder::Unspecified {
return Err(ChargeError::MissingBondOrders(g1, g2));
}
pairs.push([i, j]);
orders.push(b_order);
}
(Some(_), None) => {
return Err(ChargeError::OpenSelection { global: g1, neighbor: g2 })
}
(None, Some(_)) => {
return Err(ChargeError::OpenSelection { global: g2, neighbor: g1 })
}
(None, None) => {}
}
}
let orders = kekulize(&z, &fc, &orders, &BondAdjacency::build(z.len(), pairs.iter().copied()))
.map_err(|e| ChargeError::Kekulize(e.remap_atoms(&global)))?;
let bonds: Vec<gaff::LocalBond> = pairs
.iter()
.zip(&orders)
.map(|(&[i, j], &o)| gaff::LocalBond {
i,
j,
order: match o {
BondOrder::Double => 2,
BondOrder::Triple => 3,
_ => 1,
},
})
.collect();
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(())
}
}