sesmesh 1.3.2

Solvent Excluded Surface (Connolly surface) meshing for molecular structures
Documentation
// sesmesh — Solvent Excluded Surface meshes for molecules
// Copyright (c) 2026 Ugo Varetto
// SPDX-License-Identifier: MIT OR Apache-2.0

//! PQR reader (Spec FR-IN-5, Design §5.5): whitespace-delimited
//! `ATOM/HETATM serial name resName [chain] resSeq x y z charge radius`, as
//! written by PDB2PQR and read by APBS. `MODEL`/`ENDMDL`/`END` are handled as
//! in PDB files. PQR has no element column, so elements are inferred from atom
//! names.

use super::Parsed;
use super::lines::{Lines, column_of, fields};
use super::model::ModelBuilder;
use super::num::{parse_f32, parse_f64, parse_i32, parse_i64, show};
use crate::diag::{Diagnostics, WarningKind};
use crate::error::ParseError;
use crate::structure::{AtomRecord, Element, StringPool};

pub(crate) fn parse(data: &[u8]) -> Result<Parsed, ParseError> {
    let mut strings = StringPool::new();
    let mut diagnostics = Diagnostics::new();
    let mut models = ModelBuilder::default();
    let mut tok: Vec<&[u8]> = Vec::new();

    for (lineno, line) in Lines::new(data) {
        tok.clear();
        tok.extend(fields(line));
        let Some(&record) = tok.first() else { continue };
        let het = record.eq_ignore_ascii_case(b"HETATM");
        if !het && !record.eq_ignore_ascii_case(b"ATOM") {
            if record.eq_ignore_ascii_case(b"MODEL") {
                models.begin(tok.get(1).and_then(|t| parse_i32(t)));
            } else if record.eq_ignore_ascii_case(b"ENDMDL") || record.eq_ignore_ascii_case(b"END")
            {
                models.end();
            }
            continue;
        }
        let n = tok.len();
        if n != 10 && n != 11 {
            return Err(ParseError::new(
                lineno,
                1,
                format!(
                    "expected 10 or 11 fields (record serial name resName [chain] resSeq x y z \
                     charge radius), found {n}"
                ),
            ));
        }
        let number = |i: usize, what: &str| {
            parse_f64(tok[i]).ok_or_else(|| {
                ParseError::new(
                    lineno,
                    column_of(line, tok[i]),
                    format!("invalid {what} '{}'", show(tok[i])),
                )
            })
        };
        let mut atom = AtomRecord::new([
            number(n - 5, "x coordinate")?,
            number(n - 4, "y coordinate")?,
            number(n - 3, "z coordinate")?,
        ]);
        atom.het = het;
        let radius = number(n - 1, "radius")?;
        if radius < 0.0 {
            return Err(ParseError::new(
                lineno,
                column_of(line, tok[n - 1]),
                "negative radius",
            ));
        }
        atom.radius = Some(radius as f32);
        atom.partial_charge = parse_f32(tok[n - 2]);
        if atom.partial_charge.is_none() {
            diagnostics.warn(WarningKind::InvalidField, "invalid PQR charge", || {
                format!("line {lineno}: '{}'", show(tok[n - 2]))
            });
        }
        match parse_i64(tok[1]).and_then(|v| u32::try_from(v).ok()) {
            Some(s) => atom.serial = s,
            None => diagnostics.warn(
                WarningKind::InvalidField,
                "invalid atom serial number; using 0",
                || format!("line {lineno}: '{}'", show(tok[1])),
            ),
        }
        atom.name = strings.intern_bytes(tok[2]);
        atom.res_name = strings.intern_bytes(tok[3]);
        if n == 11 {
            atom.chain = strings.intern_bytes(tok[4]);
            atom.label_chain = atom.chain;
        }
        let seq = tok[n - 6];
        let (digits, ins) = match seq.split_last() {
            Some((&c, rest)) if c.is_ascii_alphabetic() => (rest, Some(char::from(c))),
            _ => (seq, None),
        };
        atom.ins_code = ins;
        atom.res_seq = parse_i32(digits).unwrap_or_else(|| {
            diagnostics.warn(
                WarningKind::InvalidField,
                "invalid residue number; using 0",
                || format!("line {lineno}: '{}'", show(seq)),
            );
            0
        });
        let name = String::from_utf8_lossy(tok[2]);
        let res = String::from_utf8_lossy(tok[3]);
        atom.element = Element::infer_from_name(&name, &res, het);
        if atom.element.is_none() {
            diagnostics.warn(
                WarningKind::UnknownElement,
                "element could not be inferred from the atom name",
                || format!("line {lineno}: '{name}'"),
            );
        }
        models.push(atom);
    }
    let models = models.finish();
    if models.is_empty() {
        return Err(ParseError::new(1, 1, "no ATOM or HETATM records found"));
    }
    Ok(Parsed {
        models,
        strings,
        diagnostics,
        data_block: None,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn with_and_without_chain() {
        let text = "REMARK   1 PQR file generated by hand\n\
ATOM      1  N   ALA     1     -0.677  -1.230  -0.491 -0.3000 1.8240\n\
ATOM      2  CA  ALA A   2A     0.000   0.000   0.000  0.0337 1.9080\n\
HETATM    3  ZN  ZN  B 101      5.000   5.000   5.000  2.0000 1.1000\n\
END\n";
        let p = parse(text.as_bytes()).unwrap();
        let a = &p.models[0].atoms;
        assert_eq!(a.len(), 3);
        assert_eq!(a[0].radius, Some(1.824));
        assert_eq!(a[0].partial_charge, Some(-0.3));
        assert_eq!(a[0].element, Some(Element::N));
        assert_eq!(p.strings.get(a[0].chain), "");
        assert_eq!(p.strings.get(a[1].chain), "A");
        assert_eq!((a[1].res_seq, a[1].ins_code), (2, Some('A')));
        assert_eq!(a[1].element, Some(Element::C));
        assert_eq!(a[2].element, Some(Element::Zn));
        assert!(a[2].het);
    }

    #[test]
    fn errors() {
        let e = parse(b"ATOM 1 N ALA 1 0 0 0 0\n").unwrap_err();
        assert!(e.message.contains("found 9"), "{}", e.message);
        let e = parse(b"ATOM 1 N ALA 1 0 0 0 0 -1\n").unwrap_err();
        assert_eq!(e.column, 24);
        let e = parse(b"ATOM 1 N ALA 1 0 q 0 0 1\n").unwrap_err();
        assert_eq!((e.line, e.column), (1, 18));
        assert!(parse(b"REMARK only\n").is_err());
    }
}