diff --git a/docs/RUGNUX_CLI.md b/docs/RUGNUX_CLI.md index 8538e4f8e..922161626 100644 --- a/docs/RUGNUX_CLI.md +++ b/docs/RUGNUX_CLI.md @@ -118,10 +118,12 @@ about 1 it joins, clearly below it (another crystal) it is left out, and in betw joins unless it is shown to hurt: adding it raises the held-out residual of the others' merge by more than 1%, two standard errors down (a sweep left out is named in the log). A sweep that found no lattice of the crystal on its own (it merged nothing, or correlates on no axes) is processed again given the cell of the joined sweep reaching the finest resolution. The crystal has one cell: -any sweep on the reference's axes - the ones just rescued too - whose own cell is more than 0.3% off that sweep's -(where the cell is measured rather than the distance) is processed a second time, from the distance that would -make the two cells agree, and that run replaces the first only where its intensities agree better with the -joined sweeps' (a lower held-out residual by more than twice its error) and it has no fewer fulls. Their fulls are +any sweep with a merge - joined or not, the ones just rescued too - whose own cell is more than 0.3% off that +sweep's (where the cell is measured rather than the distance), but not a whole multiple of it in volume, is +processed a second time, from the distance that would make the two cells agree. That run replaces the first only +where it has no fewer fulls and, for a sweep on the reference's axes, its intensities agree better with the +joined sweeps' (a lower held-out residual by more than twice its error); a sweep on none is then judged on its +intensities like every other. Their fulls are scaled and merged together: a per-frame scale within each sweep, the sweeps' dose order read from their relative B factors (not from the input order or the header times), a decay along that order or one B per sweep, whichever predicts held-out frames better, then the space-group search, the diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp index 431d43a85..92a9b048d 100644 --- a/rugnux/rugnux_cli.cpp +++ b/rugnux/rugnux_cli.cpp @@ -4209,20 +4209,22 @@ int RugnuxCli::RunJointSweeps(const RugnuxSweepPlan &plan) { replaced = false; } - // Every sweep on the reference's axes, joined or not - the ones just rescued too - on the target sweep's - // cell: a cell off by a few percent is itself a reason for intensities to disagree, so the join is decided - // after this, on the runs it keeps. A sweep whose cell is off the target's is processed again from the - // distance that would make the two agree, and that run replaces its first one only where it agrees better - // with the joined sweeps' intensities (HeldOutAgainst) by more than the two residuals' errors, and at no loss - // of observations: a distance is not changed on noise, and a run that integrates fewer reflections does not - // measure them better. + // Every sweep with a merge - joined or not, the ones just rescued too - on the target sweep's cell: a cell off + // by a few percent is itself a reason for intensities to disagree, or for a sweep not to be put on the + // reference's axes at all, so the join is decided after this, on the runs it keeps. A sweep whose cell is off + // the target's is processed again from the distance that would make the two agree - unless the two are + // different lattices, whose volumes are a whole multiple (2 or more) apart. On the reference's axes, the + // second run replaces the first only where it agrees better with the joined sweeps' intensities + // (HeldOutAgainst) by more than the two residuals' errors; on none, there is nothing to compare, and the + // relation made again below decides on its intensities. Never at a loss of observations: a distance is not + // changed on noise, and a run that integrates fewer reflections does not measure them better. for (size_t k = 0; target >= 0 && k < members.size(); ++k) { const std::string &decision = relation.sweeps[k].decision; - if (decision == "no merge" || decision == "no axes" || static_cast(k) == target - || !std::isfinite(members[k].distance_mm)) + if (decision == "no merge" || static_cast(k) == target || !std::isfinite(members[k].distance_mm)) continue; const double scale = VolumeLength(members[target].cell) / VolumeLength(members[k].cell); - if (std::fabs(scale - 1.0) <= SHARED_CELL_AGREEMENT) + const double volume_ratio = scale * scale * scale; + if (std::fabs(scale - 1.0) <= SHARED_CELL_AGREEMENT || std::max(volume_ratio, 1.0 / volume_ratio) >= 1.5) continue; const auto distance = static_cast(members[k].distance_mm * scale); logger.Info("Sweep {}: its cell is {:+.2f}% off sweep {}'s; processed again from {:.2f} mm", k + 1, @@ -4230,29 +4232,38 @@ int RugnuxCli::RunJointSweeps(const RugnuxSweepPlan &plan) { JointMemberSweep again = run_member(k, distance, std::nullopt, "_cell"); if (again.merged.empty()) continue; - // Against the merge of the other joined sweeps, the target first (the scale). - std::vector base{&members[target]}; - std::vector base_cob{relation.sweeps[target].cob}; - for (size_t j = 0; j < members.size(); ++j) - if (relation.sweeps[j].included && j != k && static_cast(j) != target) { - base.push_back(&members[j]); - base_cob.push_back(relation.sweeps[j].cob); - } - const JointMemberSweep &reference = members[relation.reference]; - const std::vector gains = HeldOutAgainst(base, base_cob, reference, {&members[k], &again}); - const HeldOutGain &before = gains[0], &after = gains[1]; - const double gain = before.change - after.change; - const bool better = std::isfinite(gain) && gain > 2.0 * std::hypot(before.se, after.se); const bool no_loss = again.fulls.size() >= members[k].fulls.size(); - logger.Info("Sweep {}: against the joined sweeps (scale: sweep {}), held-out residual {:+.2f}% +- {:.2f}% at " - "its own cell ({:.3f} {:.3f} {:.3f}, {} fulls), {:+.2f}% +- {:.2f}% processed again ({:.3f} {:.3f} " - "{:.3f}, {} fulls): {}", k + 1, target + 1, 100.0 * before.change, 100.0 * before.se, - members[k].cell.a, members[k].cell.b, members[k].cell.c, members[k].fulls.size(), - 100.0 * after.change, 100.0 * after.se, again.cell.a, again.cell.b, again.cell.c, - again.fulls.size(), - !better ? "the first run stands - the second agrees no better beyond the errors" - : !no_loss ? "the first run stands - the second has fewer fulls" - : "the second run is taken"); + bool better = true; + if (decision == "no axes") + logger.Info("Sweep {}: on no axes of the reference at its own cell, so nothing to compare; {} fulls there " + "({:.3f} {:.3f} {:.3f}), {} processed again ({:.3f} {:.3f} {:.3f}): {}", k + 1, + members[k].fulls.size(), members[k].cell.a, members[k].cell.b, members[k].cell.c, + again.fulls.size(), again.cell.a, again.cell.b, again.cell.c, + no_loss ? "the second run is taken" : "the first run stands - the second has fewer fulls"); + else { + // Against the merge of the other joined sweeps, the target first (the scale). + std::vector base{&members[target]}; + std::vector base_cob{relation.sweeps[target].cob}; + for (size_t j = 0; j < members.size(); ++j) + if (relation.sweeps[j].included && j != k && static_cast(j) != target) { + base.push_back(&members[j]); + base_cob.push_back(relation.sweeps[j].cob); + } + const JointMemberSweep &reference = members[relation.reference]; + const std::vector gains = HeldOutAgainst(base, base_cob, reference, {&members[k], &again}); + const HeldOutGain &before = gains[0], &after = gains[1]; + const double gain = before.change - after.change; + better = std::isfinite(gain) && gain > 2.0 * std::hypot(before.se, after.se); + logger.Info("Sweep {}: against the joined sweeps (scale: sweep {}), held-out residual {:+.2f}% +- {:.2f}% " + "at its own cell ({:.3f} {:.3f} {:.3f}, {} fulls), {:+.2f}% +- {:.2f}% processed again ({:.3f} " + "{:.3f} {:.3f}, {} fulls): {}", k + 1, target + 1, 100.0 * before.change, 100.0 * before.se, + members[k].cell.a, members[k].cell.b, members[k].cell.c, members[k].fulls.size(), + 100.0 * after.change, 100.0 * after.se, again.cell.a, again.cell.b, again.cell.c, + again.fulls.size(), + !better ? "the first run stands - the second agrees no better beyond the errors" + : !no_loss ? "the first run stands - the second has fewer fulls" + : "the second run is taken"); + } if (better && no_loss) { again.reprocessed_from_mm = members[k].distance_mm; members[k] = std::move(again);