Each blob of the refined mFo-DFc map now carries the anomalous difference map's peak height (|F+| - |F-| on the model's phases less 90 degrees, in its rms): its highest point within 1 A of the blob's peak, not the value at the peak. The two maps are on grids of their own (up to ~0.7 A apart at 2 A) and the anomalous scatterer need not be the difference density's highest point; 1 A, half the shortest metal-ligand bond, keeps a neighbouring modelled S or metal from being read as the blob's own. NaN (null in _blobs.json) where the merge kept no Bijvoet pairs, instead of 0. The ION rule reads the same value. The report's blob list shows it only where the SUMMARY's Anomalous row says "signal present" (AnomalousRow, factored out of the summary so both read one decision); without the signal it is noise and is left out. --mode refine has no merge to judge on and leaves it out. Live: rugnux_live_blob.anomalous_sigma in /rugnux/status (C++ model, python docs, frontend client and Redoc regenerated); the Rugnux page's Details get a blob table with an "anom σ" column and the structure viewer's peak label an "anom" reading, both only where anomalous_signal is set. Tests: FindDensityBlobs_AnomalousPeakNearTheBlob (a scatterer 0.7 A off the difference peak read at its own height; no map, no reading), Refinement_blob_anomalous_peak (a model missing a zinc and a water, data with the zinc's f'': zinc blob 32 sigma, water -0.1), report and live checks. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
603 lines
23 KiB
C++
603 lines
23 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include <catch2/catch_all.hpp>
|
|
|
|
#include <cctype>
|
|
#include <cmath>
|
|
#include <map>
|
|
#include <sstream>
|
|
|
|
#include "../receiver/RugnuxLiveStatus.h"
|
|
#include "../receiver/RugnuxLiveStatus.h"
|
|
#include "../rugnux/Rugnux.h"
|
|
#include "../broker/OpenAPIConvert.h"
|
|
#include "../image_puller/TestImagePuller.h"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
TEST_CASE("RugnuxLiveStatus_TimesFromFirstImage", "[RugnuxLive]") {
|
|
// 11 images at 100 Hz, the first 3 s after START, reported out of order as several forward threads do
|
|
const auto start = std::chrono::steady_clock::now() - 10s;
|
|
const auto first = start + 3s;
|
|
|
|
RugnuxLiveStatus status;
|
|
status.Start(11, 0.11, start);
|
|
for (int i: {1, 0, 2, 3, 4, 5, 6, 7, 8, 10, 9})
|
|
status.ImageReceived(first + i * 10ms);
|
|
|
|
auto s = status.Get();
|
|
CHECK(s.expected_collection_s.value() == Catch::Approx(0.11));
|
|
REQUIRE(s.images_received == 11);
|
|
REQUIRE(s.start_to_first_image_s.value() == Catch::Approx(3.0));
|
|
CHECK(!s.last_image_s);
|
|
// "now" is 10 s after START, 7 s after the first image
|
|
CHECK(s.elapsed_s == Catch::Approx(7.0).margin(0.5));
|
|
|
|
REQUIRE(status.LastImage() == first + 100ms);
|
|
s = status.Get();
|
|
REQUIRE(s.last_image_s.value() == Catch::Approx(0.1));
|
|
CHECK((s.images_received - 1) / s.last_image_s.value() == Catch::Approx(100.0));
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_BeforeFirstImage", "[RugnuxLive]") {
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, std::nullopt, std::chrono::steady_clock::now() - 2s);
|
|
status.Step("waiting");
|
|
|
|
const auto s = status.Get();
|
|
CHECK(!s.start_to_first_image_s);
|
|
CHECK(!s.expected_collection_s);
|
|
CHECK(s.elapsed_s == 0.0);
|
|
REQUIRE(s.steps.size() == 1);
|
|
CHECK(s.steps[0].started_s <= 0.0);
|
|
CHECK(!status.LastImage());
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_RunLatticeOvertakesProbe", "[RugnuxLive]") {
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
|
|
// The probe answers first, the run indexes later: the banner is the run's
|
|
status.Probe("no lattice on the first 60 deg");
|
|
CHECK(status.Get().probe == "no lattice on the first 60 deg");
|
|
status.Lattice("lattice on the sweep: monoclinic P: 35.00 29.00 63.00 90.0 105.0 90.0");
|
|
CHECK(status.Get().probe.starts_with("lattice on the sweep"));
|
|
// The run indexed before the probe answered: the probe's answer is not shown
|
|
status.Probe("no lattice on the first 60 deg");
|
|
CHECK(status.Get().probe.starts_with("lattice on the sweep"));
|
|
|
|
// The next collection starts afresh
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Probe("no lattice on the first 60 deg");
|
|
CHECK(status.Get().probe == "no lattice on the first 60 deg");
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_Clear", "[RugnuxLive]") {
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now() - 2s);
|
|
status.ImageReceived(std::chrono::steady_clock::now() - 1s);
|
|
status.Step("indexing");
|
|
status.Probe("lattice found");
|
|
status.Result("OK", "fine", {{"Space group", "P 1"}}, {"a warning"});
|
|
status.Finish(RugnuxLiveState::Done);
|
|
REQUIRE(status.LastImage());
|
|
|
|
status.Clear();
|
|
const auto s = status.Get();
|
|
CHECK(s.state == RugnuxLiveState::Idle);
|
|
CHECK(s.images_expected == 0);
|
|
CHECK(s.images_received == 0);
|
|
CHECK(s.steps.empty());
|
|
CHECK(s.probe.empty());
|
|
CHECK(s.verdict.empty());
|
|
CHECK(s.summary.empty());
|
|
CHECK(s.warnings.empty());
|
|
CHECK(!s.start_to_first_image_s);
|
|
CHECK(!s.last_image_s);
|
|
CHECK(s.elapsed_s == 0.0);
|
|
CHECK(!status.LastImage());
|
|
}
|
|
|
|
TEST_CASE("TestImagePuller_SetsReceiveTime", "[RugnuxLive]") {
|
|
TestImagePuller puller;
|
|
const auto before = std::chrono::steady_clock::now();
|
|
puller.Put(ImagePullerOutput{});
|
|
const auto given = before - 5s;
|
|
puller.Put(ImagePullerOutput{.received = given});
|
|
|
|
auto out = puller.PollImage();
|
|
REQUIRE(out);
|
|
CHECK(out->received >= before);
|
|
out = puller.PollImage();
|
|
REQUIRE(out);
|
|
CHECK(out->received == given);
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveModel_MolecularReplacement", "[RugnuxLive]") {
|
|
ProcessResult r;
|
|
CHECK(!LiveModel(r));
|
|
|
|
MolecularReplacementResult mr;
|
|
mr.ok = true;
|
|
mr.model_name = "model.cif";
|
|
mr.predicted_model = true;
|
|
mr.decision = "AGREES";
|
|
mr.d_min_search = 2.5;
|
|
MRCandidate c;
|
|
c.space_group = *gemmi::find_spacegroup_by_name("P 1 21 1");
|
|
c.copies = 2;
|
|
c.tf_z = 12.5;
|
|
c.rf_z = 6.0;
|
|
c.null_sigma = 20.0;
|
|
mr.candidates = {MRCandidate{}, c};
|
|
mr.chosen = 1;
|
|
r.model_prior = mr;
|
|
ModelValidationResult v;
|
|
v.ok = true;
|
|
v.r_work = 0.38;
|
|
v.r_free = 0.40;
|
|
v.cc_model_overall = 0.71;
|
|
v.mean_atom_density_sigma = 1.6;
|
|
v.anomalous_sites = {{"SD MET A1", 5.5}};
|
|
r.model_validation = v;
|
|
r.model_placement = "MR";
|
|
|
|
const auto m = LiveModel(r);
|
|
REQUIRE(m);
|
|
CHECK(m->placement == "MR");
|
|
CHECK(m->predicted);
|
|
CHECK(m->mr_space_group == "P 1 21 1");
|
|
CHECK(m->copies.value() == 2);
|
|
CHECK(m->tf_z.value() == Catch::Approx(12.5));
|
|
CHECK(!m->llg_z);
|
|
CHECK(m->fit_sigma.value() == Catch::Approx(20.0)); // MR's null: the rigid body's was not tested
|
|
CHECK(m->r_free.value() == Catch::Approx(0.40));
|
|
CHECK(m->cc_model.value() == Catch::Approx(0.71));
|
|
CHECK(!m->rigid_body_shift_A);
|
|
CHECK(m->anomalous_site == "SD MET A1");
|
|
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Result("OK", "fine", {}, {}, true);
|
|
status.Model(*m);
|
|
nlohmann::json j = Convert(status.Get());
|
|
CHECK(j["anomalous_signal"] == true);
|
|
CHECK(j["model"]["placement"] == "MR");
|
|
CHECK(j["model"]["copies"] == 2);
|
|
CHECK(j["model"]["r_free"].get<double>() == Catch::Approx(0.40));
|
|
CHECK(!j["model"].contains("llg_z"));
|
|
CHECK(!j["model"].contains("rigid_body_angle_deg"));
|
|
|
|
status.Clear();
|
|
CHECK(!status.Get().model);
|
|
CHECK(!status.Get().anomalous_signal);
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_Headline", "[RugnuxLive]") {
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
nlohmann::json j = Convert(status.Get());
|
|
CHECK(!j.contains("space_group"));
|
|
CHECK(!j.contains("d_min"));
|
|
CHECK(!j.contains("isa"));
|
|
CHECK(!j.contains("resolution_fit"));
|
|
|
|
status.Headline("P 1 21 1", 1.25, 24.2, 1.31);
|
|
j = Convert(status.Get());
|
|
CHECK(j["space_group"] == "P 1 21 1");
|
|
CHECK(j["d_min"].get<double>() == Catch::Approx(1.25));
|
|
CHECK(j["isa"].get<double>() == Catch::Approx(24.2));
|
|
CHECK(j["resolution_fit"].get<double>() == Catch::Approx(1.31));
|
|
|
|
// ISa undetermined, no fit
|
|
status.Headline("P 1 21 1", 1.25, std::nullopt);
|
|
j = Convert(status.Get());
|
|
CHECK(!j.contains("isa"));
|
|
CHECK(!j.contains("resolution_fit"));
|
|
|
|
status.Clear();
|
|
CHECK(status.Get().space_group.empty());
|
|
CHECK(!status.Get().d_min);
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveModel_Refinement", "[RugnuxLive]") {
|
|
ProcessResult r;
|
|
ModelValidationResult v;
|
|
v.ok = true;
|
|
v.r_work = 0.38;
|
|
v.r_free = 0.40;
|
|
r.model_validation = v;
|
|
r.model_placement = "RIGID_BODY";
|
|
CHECK(!LiveModel(r)->refinement);
|
|
|
|
RefinementResult rf;
|
|
rf.ok = true;
|
|
rf.on_gpu = true;
|
|
rf.seconds = 3.5;
|
|
rf.r_work_placement = 0.30;
|
|
rf.r_free_placement = 0.33;
|
|
rf.restrained = true;
|
|
rf.r_work = 0.19;
|
|
rf.r_free = 0.23;
|
|
rf.geometry.rmsd_bonds = 0.011;
|
|
rf.geometry.rmsd_angles = 1.6;
|
|
DensityBlob b;
|
|
b.kind = DensityBlob::Kind::Ligand;
|
|
b.centroid = gemmi::Position(1.0, 2.0, 3.0);
|
|
b.peak_sigma = 7.5;
|
|
b.volume = 40.0;
|
|
b.nearest_atom = "OG1 THR A42";
|
|
b.nearest_atom_distance = 3.1;
|
|
b.anomalous_sigma = 2.5;
|
|
rf.blobs.assign(RugnuxLiveRefinement::MAX_BLOBS + 5, b);
|
|
r.refinement = rf;
|
|
|
|
const auto m = LiveModel(r);
|
|
REQUIRE(m->refinement);
|
|
const RugnuxLiveRefinement &lr = *m->refinement;
|
|
CHECK(lr.performed);
|
|
CHECK(lr.r_free.value() == Catch::Approx(0.23));
|
|
CHECK(lr.rmsd_bonds_A.value() == Catch::Approx(0.011));
|
|
CHECK(lr.blob_count == static_cast<int64_t>(RugnuxLiveRefinement::MAX_BLOBS + 5));
|
|
CHECK(lr.blobs.size() == RugnuxLiveRefinement::MAX_BLOBS);
|
|
CHECK(lr.blobs[0].anomalous_sigma.value() == Catch::Approx(2.5));
|
|
// the placed model's R-factors are untouched
|
|
CHECK(m->r_free.value() == Catch::Approx(0.40));
|
|
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Model(*m);
|
|
nlohmann::json j = Convert(status.Get());
|
|
CHECK(j["refined_model"] == false);
|
|
CHECK(j["model"]["r_free"].get<double>() == Catch::Approx(0.40));
|
|
CHECK(j["model"]["refinement"]["r_free"].get<double>() == Catch::Approx(0.23));
|
|
CHECK(j["model"]["refinement"]["on_gpu"] == true);
|
|
CHECK(j["model"]["refinement"]["blob_count"] == RugnuxLiveRefinement::MAX_BLOBS + 5);
|
|
CHECK(j["model"]["refinement"]["blobs"].size() == RugnuxLiveRefinement::MAX_BLOBS);
|
|
CHECK(j["model"]["refinement"]["blobs"][0]["kind"] == "LIGAND");
|
|
CHECK(j["model"]["refinement"]["blobs"][0]["z"].get<double>() == Catch::Approx(3.0));
|
|
|
|
// Only the placement stage ran: its R-factors, no geometry
|
|
rf.restrained = false;
|
|
r.refinement = rf;
|
|
const auto p = LiveModel(r);
|
|
CHECK(p->refinement->r_free.value() == Catch::Approx(0.33));
|
|
CHECK(!p->refinement->rmsd_bonds_A);
|
|
|
|
// Failed
|
|
RefinementResult failed;
|
|
failed.failure_reason = "no dictionary";
|
|
r.refinement = failed;
|
|
status.Model(*LiveModel(r));
|
|
j = Convert(status.Get());
|
|
CHECK(j["model"]["refinement"]["performed"] == false);
|
|
CHECK(j["model"]["refinement"]["reason"] == "no dictionary");
|
|
CHECK(!j["model"]["refinement"].contains("r_free"));
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveModel_RefinementCancelled", "[RugnuxLive]") {
|
|
ProcessResult r;
|
|
ModelValidationResult v;
|
|
v.ok = true;
|
|
r.model_validation = v;
|
|
r.model_placement = "MR";
|
|
RefinementResult rf;
|
|
rf.ok = true;
|
|
rf.cancelled = true;
|
|
r.refinement = rf;
|
|
const auto m = LiveModel(r);
|
|
CHECK(m->refinement->cancelled);
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Model(*m);
|
|
const nlohmann::json j = Convert(status.Get());
|
|
CHECK(j["model"]["refinement"]["cancelled"] == true);
|
|
}
|
|
|
|
// A score that is not a number is left out, not written as null: the page reads every present one as a number.
|
|
TEST_CASE("RugnuxLiveModel_NonFiniteScores", "[RugnuxLive]") {
|
|
ProcessResult r;
|
|
MolecularReplacementResult mr;
|
|
mr.ok = true;
|
|
mr.d_min_search = NAN;
|
|
MRCandidate c;
|
|
c.space_group = *gemmi::find_spacegroup_by_name("P 1 21 1");
|
|
c.tf_z = NAN;
|
|
c.rf_z = INFINITY;
|
|
mr.candidates = {c};
|
|
mr.chosen = 0;
|
|
r.model_prior = mr;
|
|
ModelValidationResult v;
|
|
v.ok = true;
|
|
v.r_work = NAN;
|
|
v.r_free = NAN;
|
|
v.mean_atom_density_sigma = NAN;
|
|
r.model_validation = v;
|
|
r.model_placement = "MR";
|
|
RefinementResult rf;
|
|
rf.ok = true;
|
|
rf.restrained = true;
|
|
rf.r_work = NAN;
|
|
rf.r_free = 0.25;
|
|
rf.geometry.rmsd_bonds = NAN;
|
|
DensityBlob b;
|
|
b.nearest_atom_distance = INFINITY; // and no anomalous map: anomalous_sigma NaN
|
|
rf.blobs = {b};
|
|
r.refinement = rf;
|
|
|
|
const auto m = LiveModel(r);
|
|
REQUIRE(m);
|
|
CHECK(!m->tf_z);
|
|
CHECK(!m->rf_z);
|
|
CHECK(!m->mr_d_min);
|
|
CHECK(!m->r_free);
|
|
CHECK(!m->map_atom_sigma);
|
|
CHECK(!m->refinement->r_work);
|
|
CHECK(m->refinement->r_free.value() == Catch::Approx(0.25));
|
|
CHECK(!m->refinement->rmsd_bonds_A);
|
|
CHECK(!m->refinement->blobs.at(0).nearest_atom_distance_A);
|
|
CHECK(!m->refinement->blobs.at(0).anomalous_sigma);
|
|
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Model(*m);
|
|
const nlohmann::json j = Convert(status.Get());
|
|
CHECK(!j["model"].contains("tf_z"));
|
|
CHECK(!j["model"].contains("rf_z"));
|
|
CHECK(!j["model"].contains("r_free"));
|
|
CHECK(!j["model"]["refinement"].contains("r_work"));
|
|
CHECK(!j["model"]["refinement"]["blobs"][0].contains("nearest_atom_distance_A"));
|
|
CHECK(!j["model"]["refinement"]["blobs"][0].contains("anomalous_sigma"));
|
|
CHECK(j.dump().find("null") == std::string::npos);
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_StepsAfterCancel", "[RugnuxLive]") {
|
|
// A step covers the images that came: after a cancel, not the ones it was planned for
|
|
const auto start = std::chrono::steady_clock::now();
|
|
RugnuxLiveStatus status;
|
|
status.Start(1000, 10.0, start);
|
|
status.Step("Integration (geometry pre-pass), 600 images");
|
|
for (int i = 0; i < 384; i++)
|
|
status.ImageReceived(start + i * 10ms);
|
|
status.Step("Pre-scan");
|
|
status.Cut("cancel");
|
|
status.Step("Integration, 1000 images");
|
|
status.Step("Integration, 200 images");
|
|
|
|
const auto s = status.Get();
|
|
REQUIRE(s.steps.size() == 4);
|
|
CHECK(s.steps[0].title == "Integration (geometry pre-pass), 384 images");
|
|
CHECK(s.steps[1].title == "Pre-scan");
|
|
CHECK(s.steps[2].title == "Integration, 384 images");
|
|
CHECK(s.steps[3].title == "Integration, 200 images");
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_StepsAfterDeadline", "[RugnuxLive]") {
|
|
RugnuxLiveStatus status;
|
|
status.Start(1000, 10.0, std::chrono::steady_clock::now());
|
|
status.Step("Integration, 1000 images");
|
|
status.Cut("deadline");
|
|
CHECK(status.Get().steps[0].title == "Integration, 1000 images");
|
|
}
|
|
|
|
namespace {
|
|
MergeStatisticsShell TestShell(float d_max, float d_min, int n_obs, int n_unique, int n_possible) {
|
|
MergeStatisticsShell sh;
|
|
sh.d_max = d_max;
|
|
sh.d_min = d_min;
|
|
sh.total_observations = n_obs;
|
|
sh.unique_reflections = n_unique;
|
|
sh.possible_unique_reflections = n_possible;
|
|
sh.mean_i_over_sigma = 2000.0 * d_min / n_obs;
|
|
sh.cc_half = 0.5 + 0.1 * d_min;
|
|
sh.r_merge = 0.02 / d_min;
|
|
sh.r_meas = 0.03 / d_min;
|
|
sh.r_pim = 0.01 / d_min;
|
|
return sh;
|
|
}
|
|
|
|
// The rows of the report's shell table (operator<< of MergeStatistics, which the report prints) by their
|
|
// d_min label, and the rows of its serial table
|
|
std::map<std::string, std::vector<std::string>> ReportRows(const MergeStatistics &ms, bool serial) {
|
|
std::ostringstream text;
|
|
text << ms;
|
|
std::istringstream lines(text.str());
|
|
std::map<std::string, std::vector<std::string>> rows;
|
|
bool in_serial = false;
|
|
for (std::string line; std::getline(lines, line);) {
|
|
if (line.find("Serial statistics") != std::string::npos)
|
|
in_serial = true;
|
|
std::istringstream words(line);
|
|
std::vector<std::string> row;
|
|
for (std::string w; words >> w;)
|
|
row.push_back(w);
|
|
if (in_serial == serial && !row.empty() && (std::isdigit(row[0][0]) || row[0] == "Overall"))
|
|
rows[row[0]] = row;
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
std::string Percent(const std::optional<double> &v) {
|
|
return v ? fmt::format("{:.1f}%", 100.0 * v.value()) : "-";
|
|
}
|
|
|
|
std::string Plain(const std::optional<double> &v) {
|
|
return v ? fmt::format("{:.1f}", v.value()) : "-";
|
|
}
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveShells_AreTheReportTable", "[RugnuxLive]") {
|
|
MergeStatistics ms;
|
|
ms.shells = {TestShell(50.0, 4.0, 4000, 1000, 1010), TestShell(4.0, 3.0, 3000, 1000, 1050),
|
|
TestShell(3.0, 2.5, 0, 0, 900), // empty: no row in the report, none here
|
|
TestShell(2.5, 2.2, 900, 600, 1000)};
|
|
ms.shells[1].cc_ref = 0.93;
|
|
ms.shells[3].mean_i_over_sigma = NAN;
|
|
ms.overall = TestShell(50.0, 2.2, 7900, 2600, 3960);
|
|
|
|
SECTION("rotation") {
|
|
const auto shells = LiveShells(ms);
|
|
const auto rows = ReportRows(ms, false);
|
|
REQUIRE(shells.size() == 3);
|
|
REQUIRE(rows.size() == 4); // three shells and the Overall row
|
|
for (const auto &sh : shells) {
|
|
const auto &row = rows.at(fmt::format("{:.2f}", sh.d_min));
|
|
// d_min N_obs N_uniq N_possib Compl Mult <I/sig> R_merge R_meas R_pim CC1/2 CC* CCref CCanom SigAno
|
|
REQUIRE(row.size() == 15);
|
|
CHECK(row[1] == std::to_string(sh.n_obs));
|
|
CHECK(row[2] == std::to_string(sh.n_unique));
|
|
CHECK(row[4] == Percent(sh.completeness));
|
|
CHECK(row[5] == Plain(sh.multiplicity));
|
|
CHECK(row[6] == Plain(sh.i_over_sigma));
|
|
CHECK(row[8] == Percent(sh.r_meas));
|
|
CHECK(row[10] == Percent(sh.cc_half));
|
|
CHECK(row[12] == Percent(sh.cc_ref));
|
|
CHECK(!sh.r_split);
|
|
CHECK(!sh.r_free);
|
|
}
|
|
CHECK(shells[0].d_max == Catch::Approx(50.0));
|
|
CHECK(shells[1].cc_ref);
|
|
CHECK(!shells[2].i_over_sigma);
|
|
|
|
// The overall row of the same table
|
|
const auto overall = LiveOverall(ms);
|
|
const auto &row = rows.at("Overall");
|
|
REQUIRE(row.size() == 15);
|
|
CHECK(row[1] == std::to_string(overall.n_obs));
|
|
CHECK(row[2] == std::to_string(overall.n_unique));
|
|
CHECK(row[4] == Percent(overall.completeness));
|
|
CHECK(row[5] == Plain(overall.multiplicity));
|
|
CHECK(row[6] == Plain(overall.i_over_sigma));
|
|
CHECK(row[8] == Percent(overall.r_meas));
|
|
CHECK(row[10] == Percent(overall.cc_half));
|
|
CHECK(overall.d_min == Catch::Approx(2.2));
|
|
}
|
|
|
|
SECTION("stills") {
|
|
ms.stills = true;
|
|
ms.shells[0].n_split_pairs = 800;
|
|
ms.shells[0].r_split = 0.12;
|
|
ms.shells[0].cc_half_split = 0.9;
|
|
ms.overall.n_split_pairs = 800;
|
|
const auto shells = LiveShells(ms);
|
|
const auto rows = ReportRows(ms, false);
|
|
const auto serial = ReportRows(ms, true);
|
|
REQUIRE(shells.size() == 3);
|
|
REQUIRE(rows.size() == 4); // three shells and the Overall row
|
|
for (const auto &sh : shells) {
|
|
const auto &row = rows.at(fmt::format("{:.2f}", sh.d_min));
|
|
// No R_merge / R_meas / R_pim on stills
|
|
REQUIRE(row.size() == 12);
|
|
CHECK(row[1] == std::to_string(sh.n_obs));
|
|
CHECK(row[6] == Plain(sh.i_over_sigma));
|
|
CHECK(row[7] == Percent(sh.cc_half));
|
|
CHECK(row[9] == Percent(sh.cc_ref));
|
|
CHECK(!sh.r_meas);
|
|
// d_min N_pairs CC1/2 CC* R_split, for the shells both halves measured
|
|
const auto it = serial.find(fmt::format("{:.2f}", sh.d_min));
|
|
CHECK((it != serial.end()) == sh.r_split.has_value());
|
|
if (it != serial.end())
|
|
CHECK(it->second[4] == Percent(sh.r_split));
|
|
}
|
|
}
|
|
|
|
SECTION("R-free of the model validated on the merge") {
|
|
ModelValidationResult v;
|
|
v.cc_model_shells = {{4.0f, 0.9, 900, NAN, NAN, NAN, 0.21, 50},
|
|
{3.0f, 0.8, 900, NAN, NAN, NAN, 0.27, 45},
|
|
{2.5f, NAN, 0, NAN, NAN, NAN, NAN, 0},
|
|
{2.2f, 0.4, 500, NAN, NAN, NAN, NAN, 0}}; // no free reflection
|
|
const auto shells = LiveShells(ms, &v);
|
|
REQUIRE(shells.size() == 3);
|
|
CHECK(shells[0].r_free.value() == Catch::Approx(0.21));
|
|
CHECK(shells[1].r_free.value() == Catch::Approx(0.27));
|
|
CHECK(!shells[2].r_free);
|
|
|
|
v.ok = true;
|
|
v.r_free = 0.25;
|
|
CHECK(LiveOverall(ms, &v).r_free.value() == Catch::Approx(0.25));
|
|
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Shells("50% of the images (provisional)", LiveShells(ms), LiveOverall(ms));
|
|
// A model of another merge does not label this one
|
|
status.ShellRFree("the collection", v);
|
|
CHECK(!status.Get().shells[0].r_free);
|
|
CHECK(!status.Get().overall->r_free);
|
|
status.ShellRFree("50% of the images (provisional)", v);
|
|
CHECK(status.Get().shells[0].r_free.value() == Catch::Approx(0.21));
|
|
CHECK(status.Get().overall->r_free.value() == Catch::Approx(0.25));
|
|
|
|
nlohmann::json j = Convert(status.Get());
|
|
CHECK(j["shells_merge"] == "50% of the images (provisional)");
|
|
REQUIRE(j["shells"].size() == 3);
|
|
CHECK(j["shells"][0]["d_min"].get<double>() == Catch::Approx(4.0));
|
|
CHECK(j["shells"][0]["d_max"].get<double>() == Catch::Approx(50.0));
|
|
CHECK(j["shells"][0]["r_free"].get<double>() == Catch::Approx(0.21));
|
|
CHECK(j["shells"][0]["r_meas"].get<double>() == Catch::Approx(0.03 / 4.0));
|
|
CHECK(!j["shells"][0].contains("cc_ref"));
|
|
CHECK(!j["shells"][0].contains("r_split"));
|
|
CHECK(!j["shells"][2].contains("i_over_sigma"));
|
|
REQUIRE(j.contains("overall"));
|
|
CHECK(j["overall"]["n_unique"].get<int64_t>() == 2600);
|
|
CHECK(j["overall"]["cc_half"].get<double>() == Catch::Approx(0.5 + 0.1 * 2.2f));
|
|
CHECK(j["overall"]["r_free"].get<double>() == Catch::Approx(0.25));
|
|
|
|
status.Clear();
|
|
CHECK(status.Get().shells.empty());
|
|
CHECK(!status.Get().overall);
|
|
j = Convert(status.Get());
|
|
CHECK(!j.contains("shells"));
|
|
CHECK(!j.contains("overall"));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("RugnuxLiveStatus_OverallRFreeIsTheFinalModels", "[RugnuxLive]") {
|
|
MergeStatistics ms;
|
|
ms.shells = {TestShell(50.0, 4.0, 4000, 1000, 1010), TestShell(4.0, 2.2, 3000, 1000, 1050)};
|
|
ms.overall = TestShell(50.0, 2.2, 7000, 2000, 2060);
|
|
ModelValidationResult v;
|
|
v.ok = true;
|
|
v.r_work = 0.40;
|
|
v.r_free = 0.42;
|
|
v.cc_model_shells = {{4.0f, 0.9, 900, NAN, NAN, NAN, 0.35, 50}, {2.2f, 0.8, 900, NAN, NAN, NAN, 0.47, 45}};
|
|
RefinementResult rf;
|
|
rf.ok = true;
|
|
rf.r_work_placement = 0.36;
|
|
rf.r_free_placement = 0.39;
|
|
rf.restrained = true;
|
|
rf.r_work = 0.33;
|
|
rf.r_free = 0.37;
|
|
|
|
// Not refined: the placed model's, as the report's R_FREE
|
|
CHECK(LiveOverall(ms, &v).r_free.value() == Catch::Approx(0.42));
|
|
RefinementResult failed;
|
|
CHECK(LiveOverall(ms, &v, &failed).r_free.value() == Catch::Approx(0.42));
|
|
// Refined: the refined model's, as model.refinement.r_free and the report's REFINE_R_FREE
|
|
CHECK(LiveOverall(ms, &v, &rf).r_free.value() == Catch::Approx(0.37));
|
|
rf.restrained = false;
|
|
CHECK(LiveOverall(ms, &v, &rf).r_free.value() == Catch::Approx(0.39));
|
|
rf.restrained = true;
|
|
|
|
ProcessResult r;
|
|
r.model_validation = v;
|
|
r.model_placement = "RIGID_BODY";
|
|
r.refinement = rf;
|
|
RugnuxLiveStatus status;
|
|
status.Start(10, 1.0, std::chrono::steady_clock::now());
|
|
status.Model(*LiveModel(r));
|
|
status.Shells("the collection", LiveShells(ms, &v), LiveOverall(ms, &v, &rf));
|
|
nlohmann::json j = Convert(status.Get());
|
|
CHECK(j["overall"]["r_free"].get<double>() == j["model"]["refinement"]["r_free"].get<double>());
|
|
CHECK(j["model"]["r_free"].get<double>() == Catch::Approx(0.42));
|
|
// The shells stay the placed model's: the refinement measures no shell
|
|
CHECK(j["shells"][0]["r_free"].get<double>() == Catch::Approx(0.35));
|
|
|
|
// Serial: the model placed on a merge and refined after its table was shown
|
|
status.Shells("the collection", LiveShells(ms), LiveOverall(ms));
|
|
status.ShellRFree("the collection", v, &rf);
|
|
CHECK(status.Get().overall->r_free.value() == Catch::Approx(0.37));
|
|
CHECK(status.Get().shells[1].r_free.value() == Catch::Approx(0.47));
|
|
}
|