Merge rc187-links: model output records that describe the model written, PDB models recognised whatever record they start with
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
This commit is contained in:
commit
85f4cea1f5
5 files changed
+102
-7
No files matched your search
+3
-1
@@ -1009,7 +1009,9 @@ void populate_structure_from_pdb_stream(AnyStream& line_reader, const std::strin
|
||||
helix.end.chain_name = read_string(line+30, 2);
|
||||
helix.end.res_id = read_res_id(line+33, line+27);
|
||||
helix.set_helix_class_as_int(read_int(line+38, 2));
|
||||
if (len > 72)
|
||||
// a blank length field (columns 72-76) is "not given", as Helix::length = -1 says; read_int() would
|
||||
// make it 0, which the next writer then puts on the record and a reader checks against the residues
|
||||
if (len > 72 && std::string(line+72, std::min<size_t>(len, 77) - 72).find_first_not_of(" \r\n") != std::string::npos)
|
||||
helix.length = read_int(line+72, 5);
|
||||
st.helices.emplace_back(helix);
|
||||
|
||||
|
||||
@@ -21,9 +21,15 @@ const char *RugnuxInputKindName(RugnuxInputKind kind) {
|
||||
}
|
||||
|
||||
namespace {
|
||||
// The record names a PDB file starts with (its first line that is not blank)
|
||||
constexpr const char *PDB_RECORDS[] = {"HEADER", "TITLE ", "COMPND", "SOURCE", "KEYWDS", "EXPDTA", "AUTHOR",
|
||||
"REVDAT", "REMARK", "SEQRES", "CRYST1", "MODEL ", "ATOM ", "HETATM"};
|
||||
// The records a PDB file can start with (its first line that is not blank): every record type of the format
|
||||
// that precedes the coordinates. A file written by a program starts with whatever that program has to say -
|
||||
// a refined model with no title section starts with its HELIX or LINK records.
|
||||
constexpr const char *PDB_RECORDS[] = {"HEADER", "OBSLTE", "TITLE ", "SPLIT ", "CAVEAT", "COMPND", "SOURCE",
|
||||
"KEYWDS", "EXPDTA", "NUMMDL", "MDLTYP", "AUTHOR", "REVDAT", "SPRSDE",
|
||||
"JRNL ", "REMARK", "DBREF ", "DBREF1", "DBREF2", "SEQADV", "SEQRES",
|
||||
"MODRES", "HET ", "HETNAM", "HETSYN", "FORMUL", "HELIX ", "SHEET ",
|
||||
"SSBOND", "LINK ", "LINKR ", "CISPEP", "SITE ", "CRYST1", "ORIGX1",
|
||||
"SCALE1", "MTRIX1", "MODEL ", "ATOM ", "HETATM"};
|
||||
|
||||
// The rule, fed one line at a time; done() once the answer cannot change.
|
||||
class Sniffer {
|
||||
|
||||
@@ -852,6 +852,51 @@ TEST_CASE("WriteModel_KeepsTheDataGroupWhenItIsASubgroup", "[ModelValidation]")
|
||||
std::filesystem::remove("write_model_sub_test_model.pdb");
|
||||
}
|
||||
|
||||
// The records written beside the coordinates describe them. A LINK whose two atoms are nowhere near each
|
||||
// other in the model written - a bond a program made of a clash in a placed model, a metal's outer-sphere
|
||||
// contact - claims a bond the next program would restrain, and is left out; one at bonding distance stays. A
|
||||
// HELIX record's blank length stays blank: read as 0 and written back as 0, it made phenix refuse the file.
|
||||
TEST_CASE("WriteModel_RecordsDescribeTheModelWritten", "[ModelValidation]") {
|
||||
Logger logger("WriteModel_RecordsDescribeTheModelWritten");
|
||||
const char *pdb =
|
||||
"HELIX 1 1 CYS A 1 ALA A 3 1\n"
|
||||
"LINK SG CYS A 1 SG CYS A 2 1555 1555 2.03\n"
|
||||
"LINK SG CYS A 1 CA ALA A 3 1555 1555 6.00\n"
|
||||
"CRYST1 40.000 50.000 60.000 90.00 90.00 90.00 P 1 1\n"
|
||||
"ATOM 1 SG CYS A 1 10.000 10.000 10.000 1.00 20.00 S\n"
|
||||
"ATOM 2 SG CYS A 2 12.030 10.000 10.000 1.00 20.00 S\n"
|
||||
"ATOM 3 CA ALA A 3 16.000 10.000 10.000 1.00 20.00 C\n"
|
||||
"END\n";
|
||||
const auto input = WriteTemp("write_model_records_input.pdb", pdb);
|
||||
const gemmi::Structure st = gemmi::read_structure_gz(input, gemmi::CoorFormat::Detect);
|
||||
REQUIRE(st.connections.size() == 2);
|
||||
REQUIRE(st.helices.size() == 1);
|
||||
CHECK(st.helices[0].length == -1);
|
||||
|
||||
const UnitCell cell{.a = 40, .b = 50, .c = 60, .alpha = 90, .beta = 90, .gamma = 90};
|
||||
const gemmi::SpaceGroup *p1 = gemmi::find_spacegroup_by_name("P 1");
|
||||
REQUIRE(p1 != nullptr);
|
||||
WritePlacedModel(st, cell, *p1, "write_model_records", logger);
|
||||
|
||||
for (const char *written : {"write_model_records_model.pdb", "write_model_records_model.cif"}) {
|
||||
REQUIRE(std::filesystem::exists(written));
|
||||
const gemmi::Structure back = gemmi::read_structure_gz(written, gemmi::CoorFormat::Detect);
|
||||
REQUIRE(back.connections.size() == 1);
|
||||
CHECK(back.connections[0].partner2.res_id.seqid.num == 2);
|
||||
REQUIRE(back.helices.size() == 1);
|
||||
CHECK(back.helices[0].length == -1);
|
||||
}
|
||||
std::string line;
|
||||
std::ifstream in("write_model_records_model.pdb");
|
||||
while (std::getline(in, line) && line.rfind("HELIX", 0) != 0)
|
||||
;
|
||||
REQUIRE(line.size() >= 76);
|
||||
CHECK(line.substr(71, 5) == " ");
|
||||
|
||||
for (const char *f : {"write_model_records_input.pdb", "write_model_records_model.pdb", "write_model_records_model.cif"})
|
||||
std::filesystem::remove(f);
|
||||
}
|
||||
|
||||
// CC(model, data) has to follow where the signal actually is, or it cannot support the one-sided
|
||||
// claim it exists for. The check is closed: the "observed" intensities are the model's own with
|
||||
// Gaussian noise added, and how much noise is chosen per shell - almost none in the first, some in
|
||||
|
||||
@@ -45,13 +45,24 @@ TEST_CASE("RugnuxInputKind_Classify", "[rugnux_inputs]") {
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_image2.cbf", "data_image\n_array_data.data\n_atom_site.x\n")) == K::Images);
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_image.img", "{\nHEADER_BYTES= 512;\nDIM=2;\n}")) == K::Images);
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_binary", std::string("\0\1\2\3\4\5\6\7\0\0\0\0\0\0\0\0x", 17))) == K::Images);
|
||||
// A PDB file need not start with a title section: a refined model written without one starts with its
|
||||
// HELIX or LINK records (the first line decides the format, the atom decides the model)
|
||||
const std::string ATOM = "ATOM 1 CA ALA A 1 1.000 2.000 3.000 1.00 10.00 C\nEND\n";
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_link_first.pdb",
|
||||
"LINK SG CYS A 14 CAB HEC A 201 1555 1555 1.82\n" + ATOM)) == K::Model);
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_helix_first.pdb",
|
||||
"HELIX 1 1 VAL A 4 LYS A 14 0\nCRYST1 50.000 50.000 50.000 90.00 90.00 90.00 P 1\n" + ATOM))
|
||||
== K::Model);
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_ssbond_first.pdb",
|
||||
"SSBOND 1 CYS A 6 CYS A 127 1555 1555 2.03\n" + ATOM)) == K::Model);
|
||||
// A PDB file without an atom is not a model
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_noatom.pdb", "HEADER TEST\nEND\n")) == K::Images);
|
||||
// Both coordinates and reflections: the user has to say
|
||||
CHECK(ClassifyRugnuxInput(Write("ik_both.cif", MODEL_CIF + "loop_\n_refln.index_h\n1\n")) == K::Ambiguous);
|
||||
for (const char *f: {"ik_model.cif", "ik_sf.cif", "ik_diffrn.cif", "ik_model.pdb", "ik_model.pdb.gz", "ik_sf.cif.gz",
|
||||
"ik_model_named.mtz", "ik_mtz_named.pdb", "ik_image.h5", "ik_image.cbf", "ik_image2.cbf",
|
||||
"ik_image.img", "ik_binary", "ik_noatom.pdb", "ik_both.cif"})
|
||||
"ik_image.img", "ik_binary", "ik_noatom.pdb", "ik_both.cif", "ik_link_first.pdb",
|
||||
"ik_helix_first.pdb", "ik_ssbond_first.pdb"})
|
||||
std::filesystem::remove(f);
|
||||
}
|
||||
|
||||
|
||||
+33
-2
@@ -28,6 +28,28 @@ bool coordinates_obey(const gemmi::SpaceGroup &coordinates_group, const gemmi::S
|
||||
label_ops.begin(), label_ops.end());
|
||||
}
|
||||
|
||||
// Farther apart than this, two atoms are bonded to nothing: the longest bonds a LINK can describe are a metal's
|
||||
// to its ligands (K-O, Cs-O: up to ~3.3 A).
|
||||
constexpr double LONGEST_BOND = 3.5;
|
||||
|
||||
// A LINK / struct_conn record claims a bond, and the next program (REFMAC, phenix.refine) restrains it as one
|
||||
// whether or not the atoms are anywhere near each other - which is how a record a model arrived with pulls two
|
||||
// atoms together it was never meant to join: a bond phenix made of a clash in a placed model and wrote out, or a
|
||||
// metal's outer-sphere contact that refinement left as a contact (AddMetalLinks). The records are a statement
|
||||
// about the coordinates written beside them, so one whose two atoms are not within bonding distance in this
|
||||
// model is left out. Hydrogen-bond records make no such claim and stay.
|
||||
void DropUnbondedRecords(gemmi::Structure &st) {
|
||||
const gemmi::Model &model = st.first_model();
|
||||
std::erase_if(st.connections, [&](const gemmi::Connection &c) {
|
||||
if (c.type == gemmi::Connection::Hydrog)
|
||||
return false;
|
||||
const gemmi::const_CRA a = model.find_cra(c.partner1, true), b = model.find_cra(c.partner2, true);
|
||||
if (!a.atom || !b.atom)
|
||||
return false;
|
||||
return st.cell.find_nearest_image(a.atom->pos, b.atom->pos, c.asu).dist() > LONGEST_BOND;
|
||||
});
|
||||
}
|
||||
|
||||
// `placed` in `cell`, labelled with `space_group` wherever its coordinates obey it (see WritePlacedModel).
|
||||
// takes_model_group: the model's own group was kept instead.
|
||||
gemmi::Structure LabelledModel(const gemmi::Structure &placed, const UnitCell &cell,
|
||||
@@ -50,6 +72,7 @@ gemmi::Structure LabelledModel(const gemmi::Structure &placed, const UnitCell &c
|
||||
st.cell = cell;
|
||||
st.spacegroup_hm = (takes_model_group ? *model_group : space_group).xhm();
|
||||
st.setup_cell_images();
|
||||
DropUnbondedRecords(st);
|
||||
return st;
|
||||
}
|
||||
|
||||
@@ -91,7 +114,11 @@ std::string WithTlsRemarks(const gemmi::Structure &st, const std::string &pdb) {
|
||||
line(fmt::format(" S{}1: {:8.4f} S{}2: {:8.4f} S{}3: {:8.4f}", i + 1, g.S[i][0], i + 1, g.S[i][1], i + 1,
|
||||
g.S[i][2]));
|
||||
}
|
||||
// before the crystal's record; the model's own REMARK 3 left out
|
||||
// where the format has its remarks, after the title section and before everything else (gemmi writes
|
||||
// HELIX and LINK before CRYST1, and a REMARK among them is out of order); the model's own REMARK 3 left out
|
||||
constexpr const char *TITLE_SECTION[] = {"HEADER", "OBSLTE", "TITLE ", "SPLIT ", "CAVEAT", "COMPND", "SOURCE",
|
||||
"KEYWDS", "EXPDTA", "NUMMDL", "MDLTYP", "AUTHOR", "REVDAT", "SPRSDE",
|
||||
"JRNL ", "REMARK"};
|
||||
std::istringstream in(pdb);
|
||||
std::ostringstream out;
|
||||
std::string text;
|
||||
@@ -99,7 +126,8 @@ std::string WithTlsRemarks(const gemmi::Structure &st, const std::string &pdb) {
|
||||
while (std::getline(in, text)) {
|
||||
if (text.rfind("REMARK 3", 0) == 0)
|
||||
continue;
|
||||
if (!written && (text.rfind("CRYST1", 0) == 0 || text.rfind("ATOM", 0) == 0 || text.rfind("HETATM", 0) == 0)) {
|
||||
if (!written && std::none_of(std::begin(TITLE_SECTION), std::end(TITLE_SECTION),
|
||||
[&](const char *rec) { return text.rfind(rec, 0) == 0; })) {
|
||||
out << r.str();
|
||||
written = true;
|
||||
}
|
||||
@@ -125,6 +153,9 @@ void WritePlacedModel(const gemmi::Structure &placed,
|
||||
bool takes_model_group = false;
|
||||
gemmi::Structure st = LabelledModel(placed, cell, space_group, takes_model_group);
|
||||
const gemmi::SpaceGroup &label = takes_model_group ? *st.find_spacegroup() : space_group;
|
||||
if (st.connections.size() < placed.connections.size())
|
||||
logger.Info("Model validation: {} LINK record(s) whose atoms are farther than {} A apart in this model "
|
||||
"left out of {}", placed.connections.size() - st.connections.size(), LONGEST_BOND, cif_path);
|
||||
// Fills in entity types and label_asym_id for a model read from a PDB, which carries neither.
|
||||
// Both are no-ops where the input already had them, i.e. for an mmCIF input.
|
||||
// setup_entities and make_mmcif_document can both throw, and this runs BEFORE the reflection files
|
||||
|
||||
Reference in new issue
Block a user