leonarski_fandClaude Opus 5.5
789d927c57
The stills merge no longer forms R_merge, R_meas and R_pim. On partial observations scaled to full equivalents they measure the scatter of the partials, not the error of the merged intensity, and read from a hundred to several thousand percent. A stills report has no R_MERGE= / R_MEAS= / R_PIM= (nor REFRES_R_MEAS=), its shell tables drop the three columns, the summary's Signal row drops R_meas, and the mmCIF writes ? for the three items. R_SPLIT, CC1/2, CC*, CC_anom, SigAno, multiplicity and I/sigma are reported as before; the observation counts are unchanged. The viewer's merge-statistics window shows R-split in place of R-meas for a stills merge. The battery's report reader takes a shell table without an R_meas column, and the stills A/B script drops its R_meas columns. Rotation output is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HVeDQqN9qRD57vnShzTC37
502 lines
23 KiB
C++
502 lines
23 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include "JFJochMergeStatsWindow.h"
|
|
#include "../ViewerTheme.h"
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
|
|
#include <QButtonGroup>
|
|
#include <QComboBox>
|
|
#include <QFontDatabase>
|
|
#include <QFrame>
|
|
#include <QGridLayout>
|
|
#include <QHBoxLayout>
|
|
#include <QPainter>
|
|
#include <QPlainTextEdit>
|
|
#include <QHeaderView>
|
|
#include <QLabel>
|
|
#include <QStackedWidget>
|
|
#include <QStringList>
|
|
#include <QTableWidget>
|
|
#include <QToolButton>
|
|
#include <QVBoxLayout>
|
|
#include <QtCharts/QChart>
|
|
#include <QtCharts/QChartView>
|
|
#include <QtCharts/QLineSeries>
|
|
#include <QtCharts/QLogValueAxis>
|
|
#include <QtCharts/QScatterSeries>
|
|
#include <QtCharts/QValueAxis>
|
|
|
|
#include "../charts/JFJochSimpleChartView.h"
|
|
#include "../widgets/ToolbarIcons.h"
|
|
|
|
namespace {
|
|
// Per-shell metric value (NaN -> dropped by the chart). Keep in sync with the combo entries.
|
|
// A stills merge has no R-meas; R-split, the serial R, takes its place.
|
|
double ShellMetric(const MergeStatisticsShell &s, int metric, bool stills) {
|
|
switch (metric) {
|
|
case 0: return s.cc_half * 100.0; // CC1/2 (%)
|
|
case 1: return (stills ? s.r_split : s.r_meas) * 100.0; // R-meas / R-split (%)
|
|
case 2: return s.mean_i_over_sigma; // <I/sigma>
|
|
case 3: return s.possible_unique_reflections > 0 // Completeness (%)
|
|
? 100.0 * s.unique_reflections / s.possible_unique_reflections : NAN;
|
|
case 4: return s.unique_reflections > 0 // Multiplicity
|
|
? static_cast<double>(s.total_observations) / s.unique_reflections : NAN;
|
|
case 5: return s.cc_ref * 100.0; // CCref (%)
|
|
default: return NAN;
|
|
}
|
|
}
|
|
|
|
// A big-number "card" for the hero row: large navy value over a small grey caption.
|
|
QWidget *MakeCard(const QString &value, const QString &caption, QWidget *parent) {
|
|
auto *card = new QFrame(parent);
|
|
card->setFrameShape(QFrame::StyledPanel);
|
|
auto *l = new QVBoxLayout(card);
|
|
l->setContentsMargins(12, 8, 12, 8);
|
|
l->setSpacing(0);
|
|
auto *v = new QLabel(value, card);
|
|
v->setTextFormat(Qt::RichText); // the space group carries <sub>
|
|
QFont f = v->font();
|
|
f.setPointSizeF(f.pointSizeF() * 2.2);
|
|
f.setBold(true);
|
|
v->setFont(f);
|
|
SetThemedStyleSheet(v, [] { return "color: " + AccentTextColor().name() + ";"; });
|
|
v->setAlignment(Qt::AlignCenter);
|
|
auto *c = new QLabel(caption, card);
|
|
c->setStyleSheet("color: gray;");
|
|
c->setAlignment(Qt::AlignCenter);
|
|
l->addWidget(v);
|
|
l->addWidget(c);
|
|
return card;
|
|
}
|
|
|
|
// The short Hermann-Mauguin symbol as rich text, screw axes subscripted and rotoinversions
|
|
// overlined: "P 1 21 1" -> P2<sub>1</sub>, "P 41 21 2" -> P4<sub>1</sub>2<sub>1</sub>2. Built from
|
|
// the spaced symbol, where short_name()'s run-together digits are ambiguous (P622 vs P6_2 2).
|
|
QString SpaceGroupHtml(const gemmi::SpaceGroup &sg) {
|
|
std::string hm = sg.hm;
|
|
// the monoclinic shortening of short_name(): "P 1 21 1" -> "P 21"
|
|
if (hm.size() > 6 && hm[2] == '1' && hm[hm.size() - 2] == ' ' && hm.back() == '1')
|
|
hm = hm[0] + hm.substr(3, hm.size() - 3 - 2);
|
|
if (sg.ext == 'H')
|
|
hm[0] = 'H';
|
|
QString out;
|
|
for (const auto &token : QString::fromStdString(hm).split(' ', Qt::SkipEmptyParts)) {
|
|
if (token.size() >= 2 && token[0] == '-')
|
|
out += "<span style=\"text-decoration: overline\">" + token.mid(1, 1) + "</span>" + token.mid(2);
|
|
else if (token.size() >= 2 && token[0].isDigit() && token[1].isDigit())
|
|
out += token.left(1) + "<sub>" + token.mid(1, 1) + "</sub>" + token.mid(2);
|
|
else
|
|
out += token;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Status light of a pathology check: green tick absent, red cross present, grey dash undetermined.
|
|
QPixmap CheckIcon(ReportCheck::Status status, int size, qreal dpr) {
|
|
QPixmap pm(QSize(size, size) * dpr);
|
|
pm.setDevicePixelRatio(dpr);
|
|
pm.fill(Qt::transparent);
|
|
QPainter p(&pm);
|
|
p.setRenderHint(QPainter::Antialiasing);
|
|
const QColor fill = status == ReportCheck::Status::Present ? QColor(200, 40, 40)
|
|
: status == ReportCheck::Status::Absent ? QColor(40, 150, 70)
|
|
: QColor(150, 150, 150);
|
|
p.setPen(Qt::NoPen);
|
|
p.setBrush(fill);
|
|
p.drawEllipse(QRectF(0.5, 0.5, size - 1.0, size - 1.0));
|
|
p.setPen(QPen(Qt::white, size / 8.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
|
|
const double u = size / 16.0;
|
|
if (status == ReportCheck::Status::Absent)
|
|
p.drawPolyline(QPolygonF({QPointF(4.5 * u, 8.5 * u), QPointF(7 * u, 11 * u), QPointF(11.5 * u, 5.5 * u)}));
|
|
else if (status == ReportCheck::Status::Present) {
|
|
p.drawLine(QPointF(5 * u, 5 * u), QPointF(11 * u, 11 * u));
|
|
p.drawLine(QPointF(11 * u, 5 * u), QPointF(5 * u, 11 * u));
|
|
} else
|
|
p.drawLine(QPointF(4.5 * u, 8 * u), QPointF(11.5 * u, 8 * u));
|
|
return pm;
|
|
}
|
|
}
|
|
|
|
JFJochMergeStatsWindow::JFJochMergeStatsWindow(const QString &title, const MergeStatistics &stats,
|
|
double isa, bool has_reference,
|
|
const TwinningAnalysisResult &twinning,
|
|
const std::optional<gemmi::SpaceGroup> &space_group,
|
|
const std::optional<SearchSpaceGroupResult> &space_group_search,
|
|
const std::vector<std::pair<float, float>> &merged_i_sigma,
|
|
const QString &report,
|
|
const std::vector<ReportCheck> &checks,
|
|
QWidget *parent)
|
|
: QWidget(parent, Qt::Window), stats_(stats), has_reference_(has_reference) {
|
|
setWindowTitle("Merge statistics — " + title);
|
|
setAttribute(Qt::WA_DeleteOnClose);
|
|
resize(740, 560);
|
|
|
|
auto *layout = new QVBoxLayout(this);
|
|
|
|
// --- Hero row: overall numbers ---
|
|
const auto &o = stats_.overall;
|
|
const double completeness = o.possible_unique_reflections > 0
|
|
? 100.0 * o.unique_reflections / o.possible_unique_reflections : NAN;
|
|
const double multiplicity = o.unique_reflections > 0
|
|
? static_cast<double>(o.total_observations) / o.unique_reflections : NAN;
|
|
auto pct = [](double v) { return std::isfinite(v) ? QString::number(v, 'f', 1) + "%" : QStringLiteral("—"); };
|
|
auto num = [](double v, int d) { return std::isfinite(v) ? QString::number(v, 'f', d) : QStringLiteral("—"); };
|
|
|
|
auto *hero = new QHBoxLayout();
|
|
// High-resolution limit of the merge (d_min). When no scaling resolution limit is given it is set
|
|
// by the CC1/2 logistic cutoff, so it varies per run - show it first.
|
|
if (o.d_min < o.d_max)
|
|
hero->addWidget(MakeCard(QString::asprintf("%.2f", o.d_min), "Resolution [Å]", this));
|
|
if (!std::isnan(isa)) // NaN: a stills merge, which reports no ISa
|
|
hero->addWidget(MakeCard(num(isa, 1), "ISa", this));
|
|
hero->addWidget(MakeCard(pct(o.cc_half * 100.0), "CC½", this));
|
|
if (stats_.stills)
|
|
hero->addWidget(MakeCard(pct(o.r_split * 100.0), "R-split", this));
|
|
else
|
|
hero->addWidget(MakeCard(pct(o.r_meas * 100.0), "R-meas", this));
|
|
hero->addWidget(MakeCard(pct(completeness), "Completeness", this));
|
|
hero->addWidget(MakeCard(num(multiplicity, 1), "Multiplicity", this));
|
|
// Wilson B describes how fast the intensities fall off with resolution; the radiation-damage
|
|
// Delta-B is how much MORE they fall off by the end of the run than at the start (rotation only).
|
|
if (std::isfinite(stats_.wilson_b))
|
|
hero->addWidget(MakeCard(num(stats_.wilson_b, 1), "Wilson B [Ų]", this));
|
|
if (std::isfinite(stats_.radiation_damage_delta_b)) {
|
|
const double db = stats_.radiation_damage_delta_b;
|
|
hero->addWidget(MakeCard((db > 0 ? "+" : "") + num(db, 1), "ΔB, damage [Ų]", this));
|
|
}
|
|
if (has_reference_)
|
|
hero->addWidget(MakeCard(pct(o.cc_ref * 100.0), "CCref", this));
|
|
if (space_group.has_value())
|
|
hero->addWidget(MakeCard(SpaceGroupHtml(*space_group), "Space group", this));
|
|
layout->addLayout(hero);
|
|
|
|
// --- Pathology checklist, as phenix.xtriage lists its tests: one status light per pathology the
|
|
// report's summary looks for, its words and the warnings it raised in the tooltip.
|
|
if (!checks.empty()) {
|
|
auto *grid = new QGridLayout();
|
|
grid->setHorizontalSpacing(16);
|
|
grid->setVerticalSpacing(2);
|
|
constexpr int columns = 4;
|
|
for (int i = 0; i < static_cast<int>(checks.size()); ++i) {
|
|
const auto &c = checks[i];
|
|
auto *item = new QWidget(this);
|
|
auto *l = new QHBoxLayout(item);
|
|
l->setContentsMargins(0, 0, 0, 0);
|
|
l->setSpacing(6);
|
|
auto *icon = new QLabel(item);
|
|
icon->setPixmap(CheckIcon(c.status, 14, devicePixelRatioF()));
|
|
auto *label = new QLabel(QString::fromStdString(c.label), item);
|
|
if (c.status == ReportCheck::Status::Present) {
|
|
QFont f = label->font();
|
|
f.setBold(true);
|
|
label->setFont(f);
|
|
} else if (c.status == ReportCheck::Status::Undetermined) {
|
|
label->setStyleSheet("color: gray;");
|
|
}
|
|
l->addWidget(icon);
|
|
l->addWidget(label);
|
|
l->addStretch();
|
|
QString tip = "<b>" + QString::fromStdString(c.label).toHtmlEscaped() + "</b>: "
|
|
+ QString::fromStdString(c.text).toHtmlEscaped();
|
|
if (!c.detail.empty() && c.detail != c.text)
|
|
tip += "<br><br>" + QString::fromStdString(c.detail).toHtmlEscaped().replace('\n', "<br><br>");
|
|
item->setToolTip("<qt>" + tip + "</qt>");
|
|
grid->addWidget(item, i / columns, i % columns);
|
|
}
|
|
layout->addLayout(grid);
|
|
}
|
|
|
|
// De-novo space-group search: the point group + the ranked candidates it scored (only present when
|
|
// the space group was not fixed by the user). A summary line above a compact table.
|
|
if (space_group_search.has_value() && !space_group_search->candidates.empty()) {
|
|
const auto &sgs = *space_group_search;
|
|
QString summary = "Point group " + QString::fromStdString(sgs.point_group_hm.empty() ? "?" : sgs.point_group_hm);
|
|
if (!sgs.alternatives.empty()) {
|
|
QStringList alts;
|
|
for (const auto &alt : sgs.alternatives)
|
|
alts << SpaceGroupHtml(alt);
|
|
summary += " · indistinguishable from these data: " + alts.join(", ");
|
|
}
|
|
auto *sgLabel = new QLabel(summary, this);
|
|
sgLabel->setTextFormat(Qt::RichText);
|
|
sgLabel->setStyleSheet("color: gray;");
|
|
layout->addWidget(sgLabel);
|
|
|
|
auto *sgTable = new QTableWidget(this);
|
|
sgTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
|
sgTable->verticalHeader()->setVisible(false);
|
|
const QStringList sgHeaders{"Space group", "Absent", "Viol.", "⟨I/σ⟩ abs", "⟨I/σ⟩ pres", "Consistent"};
|
|
sgTable->setColumnCount(sgHeaders.size());
|
|
sgTable->setHorizontalHeaderLabels(sgHeaders);
|
|
sgTable->setRowCount(static_cast<int>(sgs.candidates.size()));
|
|
for (int i = 0; i < static_cast<int>(sgs.candidates.size()); ++i) {
|
|
const auto &c = sgs.candidates[i];
|
|
int col = 0;
|
|
auto set = [&](const QString &t, bool leftAlign = false) {
|
|
auto *it = new QTableWidgetItem(t);
|
|
it->setTextAlignment((leftAlign ? Qt::AlignLeft : Qt::AlignRight) | Qt::AlignVCenter);
|
|
if (c.selected) { QFont f = it->font(); f.setBold(true); it->setFont(f); }
|
|
sgTable->setItem(i, col++, it);
|
|
};
|
|
set(QString::fromStdString(c.space_group.short_name()) + (c.selected ? " *" : ""), true);
|
|
set(QString::number(c.absent_observed));
|
|
set(QString::number(c.absent_violations));
|
|
set(QString::number(c.absent_mean_i_over_sigma, 'f', 2));
|
|
set(QString::number(c.present_mean_i_over_sigma, 'f', 2));
|
|
set(c.consistent ? QStringLiteral("yes") : QStringLiteral("no"));
|
|
}
|
|
sgTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
|
|
sgTable->setMaximumHeight(160); // a secondary detail — keep the shells plot the focus
|
|
layout->addWidget(sgTable);
|
|
}
|
|
|
|
// --- Twinning test (Padilla-Yeates L-test + second moment) ---
|
|
// A red-outlined banner flags suspected twinning; otherwise a quiet grey "all clear".
|
|
if (twinning.l_test_pairs > 0) {
|
|
QString text = QString("Twinning: ⟨|L|⟩ = %1 ⟨I²⟩/⟨I⟩² = %2")
|
|
.arg(twinning.mean_abs_l, 0, 'f', 3)
|
|
.arg(twinning.second_moment, 0, 'f', 2);
|
|
text += " — " + QString::fromStdString(TwinningVerdictLine(twinning));
|
|
|
|
auto *banner = new QLabel(text, this);
|
|
banner->setContentsMargins(10, 6, 10, 6);
|
|
if (twinning.twinning_suspected)
|
|
SetThemedStyleSheet(banner, [] {
|
|
return QString("color: %1; border: 1px solid red; border-radius: 4px;")
|
|
.arg(DarkTheme() ? "#FF7B72" : "rgb(160,0,0)");
|
|
});
|
|
else
|
|
banner->setStyleSheet("color: gray;");
|
|
layout->addWidget(banner);
|
|
}
|
|
|
|
// --- Controls: plot/table view toggle (icon buttons) + per-resolution metric selector ---
|
|
auto *row = new QHBoxLayout();
|
|
auto *plotBtn = new QToolButton(this);
|
|
plotBtn->setIcon(ToolbarIcons::linePlot());
|
|
plotBtn->setCheckable(true);
|
|
plotBtn->setChecked(true);
|
|
plotBtn->setToolTip("Per-resolution plot");
|
|
SetThemedStyleSheet(plotBtn, ToolbarIcons::buttonStyle);
|
|
auto *tableBtn = new QToolButton(this);
|
|
tableBtn->setIcon(ToolbarIcons::table());
|
|
tableBtn->setCheckable(true);
|
|
tableBtn->setToolTip("Per-shell table");
|
|
SetThemedStyleSheet(tableBtn, ToolbarIcons::buttonStyle);
|
|
auto *isaBtn = new QToolButton(this);
|
|
isaBtn->setIcon(ToolbarIcons::linePlot());
|
|
isaBtn->setCheckable(true);
|
|
isaBtn->setToolTip("ISa diagnostic: merged I/σ against I");
|
|
SetThemedStyleSheet(isaBtn, ToolbarIcons::buttonStyle);
|
|
auto *reportBtn = new QToolButton(this);
|
|
reportBtn->setText("Report");
|
|
reportBtn->setCheckable(true);
|
|
reportBtn->setToolTip("The rugnux result report, as written to <prefix>_report.txt");
|
|
SetThemedStyleSheet(reportBtn, ToolbarIcons::buttonStyle);
|
|
auto *viewGroup = new QButtonGroup(this);
|
|
viewGroup->setExclusive(true);
|
|
viewGroup->addButton(plotBtn, 0);
|
|
viewGroup->addButton(tableBtn, 1);
|
|
viewGroup->addButton(isaBtn, 2);
|
|
viewGroup->addButton(reportBtn, 3);
|
|
row->addWidget(plotBtn);
|
|
row->addWidget(tableBtn);
|
|
row->addWidget(isaBtn);
|
|
row->addWidget(reportBtn);
|
|
row->addSpacing(12);
|
|
metricLabel_ = new QLabel("Metric:", this);
|
|
row->addWidget(metricLabel_);
|
|
metric_ = new QComboBox(this);
|
|
metric_->addItem("CC½ (%)", 0);
|
|
metric_->addItem(stats_.stills ? "R-split (%)" : "R-meas (%)", 1);
|
|
metric_->addItem("⟨I/σ⟩", 2);
|
|
metric_->addItem("Completeness (%)", 3);
|
|
metric_->addItem("Multiplicity", 4);
|
|
if (has_reference_)
|
|
metric_->addItem("CCref (%)", 5);
|
|
row->addWidget(metric_);
|
|
row->addStretch();
|
|
layout->addLayout(row);
|
|
|
|
// --- Stacked plot / table ---
|
|
stack_ = new QStackedWidget(this);
|
|
chart_ = new JFJochSimpleChartView(this);
|
|
table_ = new QTableWidget(this);
|
|
table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
|
table_->verticalHeader()->setVisible(false);
|
|
stack_->addWidget(chart_); // page 0
|
|
stack_->addWidget(table_); // page 1
|
|
isa_page_ = std::isnan(isa) ? nullptr : buildIsaDiagnostic(merged_i_sigma, isa);
|
|
if (isa_page_)
|
|
stack_->addWidget(isa_page_); // page 2
|
|
else
|
|
isaBtn->setEnabled(false);
|
|
// The report is prose and fixed-width tables meant to be read as written - a plain text view
|
|
// in a fixed-width font, never wrapped.
|
|
if (!report.isEmpty()) {
|
|
auto *report_view = new QPlainTextEdit(this);
|
|
report_view->setReadOnly(true);
|
|
report_view->setLineWrapMode(QPlainTextEdit::NoWrap);
|
|
report_view->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
|
|
report_view->setPlainText(report);
|
|
report_page_ = report_view;
|
|
stack_->addWidget(report_page_);
|
|
} else {
|
|
reportBtn->setEnabled(false);
|
|
}
|
|
layout->addWidget(stack_, 1);
|
|
|
|
connect(metric_, &QComboBox::currentIndexChanged, this, [this](int) { updatePlot(); });
|
|
// Button ids map to page widgets, not stack indices: an absent page (no ISa scatter, no
|
|
// report) would otherwise shift every page behind it.
|
|
connect(viewGroup, &QButtonGroup::idClicked, this, [this](int idx) {
|
|
QWidget *const pages[] = {chart_, table_, isa_page_, report_page_};
|
|
if (idx >= 0 && idx < 4 && pages[idx])
|
|
stack_->setCurrentWidget(pages[idx]);
|
|
metric_->setVisible(idx == 0); // the metric selector + its label only apply to the plot
|
|
metricLabel_->setVisible(idx == 0);
|
|
});
|
|
|
|
buildTable();
|
|
updatePlot();
|
|
}
|
|
|
|
// Merged I/sigma against I. The error model says sigma -> b*I for strong reflections, so I/sigma
|
|
// flattens off at 1/b = ISa: the plot shows whether the reported number is where the data actually
|
|
// level out. Log intensity axis, because the reflections span several decades and the asymptote lives
|
|
// at the strong end.
|
|
QWidget *JFJochMergeStatsWindow::buildIsaDiagnostic(const std::vector<std::pair<float, float>> &i_sigma,
|
|
double isa) {
|
|
auto *points = new QScatterSeries();
|
|
points->setName("merged reflections");
|
|
points->setMarkerSize(4.0);
|
|
points->setBorderColor(Qt::transparent);
|
|
QColor point_color = AccentTextColor();
|
|
point_color.setAlpha(0x60);
|
|
points->setColor(point_color);
|
|
|
|
double i_lo = std::numeric_limits<double>::max(), i_hi = 0.0, r_hi = 0.0;
|
|
for (const auto &[I, sigma] : i_sigma) {
|
|
if (!(I > 0.0f) || !(sigma > 0.0f))
|
|
continue; // the log axis cannot show a non-positive intensity
|
|
const double ratio = I / sigma;
|
|
points->append(I, ratio);
|
|
i_lo = std::min(i_lo, static_cast<double>(I));
|
|
i_hi = std::max(i_hi, static_cast<double>(I));
|
|
r_hi = std::max(r_hi, ratio);
|
|
}
|
|
if (points->count() < 2 || !(i_hi > i_lo)) {
|
|
delete points;
|
|
return nullptr;
|
|
}
|
|
|
|
auto *chart = new QChart();
|
|
StyleChart(chart);
|
|
chart->legend()->setVisible(false);
|
|
chart->addSeries(points);
|
|
|
|
auto *ax = new QLogValueAxis();
|
|
ax->setBase(10.0);
|
|
ax->setTitleText("merged I");
|
|
ax->setRange(i_lo, i_hi);
|
|
auto *ay = new QValueAxis();
|
|
ay->setTitleText("merged I/σ");
|
|
ay->setRange(0.0, std::max(r_hi, std::isfinite(isa) ? isa * 1.2 : 0.0) * 1.05);
|
|
chart->addAxis(ax, Qt::AlignBottom);
|
|
chart->addAxis(ay, Qt::AlignLeft);
|
|
StyleChartAxes(chart);
|
|
points->attachAxis(ax);
|
|
points->attachAxis(ay);
|
|
|
|
if (std::isfinite(isa) && isa > 0.0) {
|
|
auto *line = new QLineSeries();
|
|
line->append(i_lo, isa);
|
|
line->append(i_hi, isa);
|
|
QPen pen(AlertTextColor());
|
|
pen.setStyle(Qt::DashLine);
|
|
pen.setWidth(2);
|
|
line->setPen(pen);
|
|
chart->addSeries(line);
|
|
line->attachAxis(ax);
|
|
line->attachAxis(ay);
|
|
}
|
|
|
|
auto *view = new QChartView(chart, this);
|
|
view->setRenderHint(QPainter::Antialiasing);
|
|
view->setToolTip(std::isfinite(isa) && isa > 0.0
|
|
? QString("Dashed line: reported ISa = %1. The strong reflections should level "
|
|
"off there.").arg(isa, 0, 'f', 1)
|
|
: QString("No ISa was determined for this merge."));
|
|
return view;
|
|
}
|
|
|
|
void JFJochMergeStatsWindow::updatePlot() {
|
|
const int metric = metric_->currentData().toInt();
|
|
std::vector<float> x, y;
|
|
double dmax = 0.0;
|
|
x.reserve(stats_.shells.size());
|
|
y.reserve(stats_.shells.size());
|
|
for (const auto &s: stats_.shells) {
|
|
x.push_back(s.mean_one_over_d2);
|
|
const double v = ShellMetric(s, metric, stats_.stills);
|
|
y.push_back(static_cast<float>(v));
|
|
if (std::isfinite(v))
|
|
dmax = std::max(dmax, v);
|
|
}
|
|
// Absolute y-axis so positions are comparable: CC1/2 + CCref are 0..100, completeness 0..(>=100),
|
|
// multiplicity / R-meas / I-sigma start at 0. It has to be given to UpdateData rather than set
|
|
// on the axis afterwards, or the tick labels still describe the range of the data.
|
|
double ymax = 1.0;
|
|
switch (metric) {
|
|
case 0: case 5: ymax = 100.0; break; // CC1/2, CCref
|
|
case 3: ymax = std::max(100.0, dmax * 1.05); break; // Completeness
|
|
default: ymax = dmax > 0.0 ? dmax * 1.05 : 1.0; break; // R-meas, I/sigma, multiplicity
|
|
}
|
|
chart_->UpdateData(x, y, "Resolution [Å]", metric_->currentText(), true,
|
|
std::make_pair(0.0, ymax));
|
|
}
|
|
|
|
void JFJochMergeStatsWindow::buildTable() {
|
|
QStringList headers{"Res. [Å]", "N_obs", "Unique", "Compl. %", "Mult.", "⟨I/σ⟩",
|
|
stats_.stills ? "R-split %" : "R-meas %", "CC½ %"};
|
|
if (has_reference_)
|
|
headers << "CCref %";
|
|
table_->setColumnCount(headers.size());
|
|
table_->setHorizontalHeaderLabels(headers);
|
|
table_->setRowCount(static_cast<int>(stats_.shells.size()) + 1); // shells + overall
|
|
|
|
auto fillRow = [&](int rowIdx, const MergeStatisticsShell &s, const QString &resLabel) {
|
|
int c = 0;
|
|
auto set = [&](const QString &t) {
|
|
auto *it = new QTableWidgetItem(t);
|
|
it->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter); // numbers right-aligned
|
|
table_->setItem(rowIdx, c++, it);
|
|
};
|
|
const double compl_ = s.possible_unique_reflections > 0
|
|
? 100.0 * s.unique_reflections / s.possible_unique_reflections : NAN;
|
|
const double mult = s.unique_reflections > 0
|
|
? static_cast<double>(s.total_observations) / s.unique_reflections : NAN;
|
|
set(resLabel);
|
|
set(QString::number(s.total_observations));
|
|
set(QString::number(s.unique_reflections));
|
|
set(std::isfinite(compl_) ? QString::number(compl_, 'f', 1) : QStringLiteral("—"));
|
|
set(std::isfinite(mult) ? QString::number(mult, 'f', 1) : QStringLiteral("—"));
|
|
set(QString::number(s.mean_i_over_sigma, 'f', 1));
|
|
set(QString::number((stats_.stills ? s.r_split : s.r_meas) * 100.0, 'f', 1));
|
|
set(QString::number(s.cc_half * 100.0, 'f', 1));
|
|
if (has_reference_)
|
|
set(QString::number(s.cc_ref * 100.0, 'f', 1));
|
|
};
|
|
|
|
int rowIdx = 0;
|
|
for (const auto &s: stats_.shells)
|
|
fillRow(rowIdx++, s, QString::number(s.d_min, 'f', 2));
|
|
fillRow(rowIdx, stats_.overall, QStringLiteral("Overall"));
|
|
|
|
// Equal-width columns that fill the table (no super-wide last column).
|
|
table_->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
|
|
}
|