Move the atomic-model code to image_analysis/structure_refinement/ and WriteModel to writer/

A pure move. ModelValidation, RigidBodyRefine, RigidBodyGPU, ModelFFT, ModelGrid,
ModelScaling, ModelMaskGPU, ModelScaleGPU and SigmaA - everything that works on an
atomic model - become the JFJochStructureRefinement library, linked by
JFJochImageAnalysis. WriteModel (the placed-model mmCIF/PDB writer) goes to writer/
as its own small JFJochModelWriter target, so JFJochWriter, which a writer-only build
compiles, does not gain a gemmi dependency. Only include paths and CMake lists change.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SVmAWnzCmRKAXVUCdc4iNi

writer/WriteModel.cpp

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "WriteModel.h"
+
+#include <algorithm>
+#include <fstream>
+
+#include <gemmi/to_mmcif.hpp>  // make_mmcif_document
+#include <gemmi/to_cif.hpp>    // write_cif_to_stream
+#include <gemmi/to_pdb.hpp>    // write_pdb
+#include <gemmi/polyheur.hpp>  // setup_entities
+
+#include "../common/Logger.h"
+
+namespace {
+
+// Do the coordinates of a model built in `coordinates_group` obey `label` as well? They do when every
+// operation of `label` is one of theirs, i.e. when `label` is a subgroup: the file then holds more
+// than one asymmetric unit of it, which is allowed and is what a model always does in P1. They do not
+// when `label` has an operation of its own, and then the label is a lie a reader acts on - it
+// generates atoms from that operation, and the crystal it builds is not the one in the file.
+bool coordinates_obey(const gemmi::SpaceGroup &coordinates_group, const gemmi::SpaceGroup &label) {
+    const std::vector<gemmi::Op> coordinate_ops = coordinates_group.operations().all_ops_sorted();
+    const std::vector<gemmi::Op> label_ops = label.operations().all_ops_sorted();
+    return std::includes(coordinate_ops.begin(), coordinate_ops.end(),
+                         label_ops.begin(), label_ops.end());
+}
+
+}  // namespace
+
+void WritePlacedModel(const gemmi::Structure &placed,
+                      const UnitCell &cell,
+                      const gemmi::SpaceGroup &space_group,
+                      const std::string &output_prefix,
+                      Logger &logger) {
+    const std::string cif_path = output_prefix + "_model.cif";
+    // PDB as well as mmCIF, because the fragment-screening tools this file exists for take a PDB:
+    // PanDDA's per-dataset input is <name>.pdb beside <name>.mtz, and dimple produces the same pair.
+    // Same coordinates, same frame, both formats - a PDB cannot hold every cell, so it is written
+    // when it can be and skipped, with a line saying so, when it cannot.
+    const std::string pdb_path = output_prefix + "_model.pdb";
+
+    gemmi::Structure st = placed;
+    // The cell is the data's, taken from the same value the reflection files are written from: the
+    // coordinates were re-fractionalized into it and genuinely sit there.
+    //
+    // The group is the data's too wherever the coordinates obey it, which is the ordinary case and the
+    // one that matters - the label then matches the .mtz beside it, the enantiomorph in particular,
+    // since --model can adopt the model's and that is neither the data's original label nor,
+    // necessarily, the one the input model arrived with. Where they do not obey it the model's own
+    // group is written instead. Data merged in a supergroup of the model's - a run that over-merged
+    // across a pseudo-symmetry twofold, or a hand the model's fit did not earn - would otherwise put
+    // operations on the file that its contents contradict, and a refinement program expands them: the
+    // structure it refines is not the model, and it says so nowhere. A pair whose two files disagree
+    // is worth a warning; a coordinate file that is quietly wrong on its own is not worth writing.
+    const gemmi::SpaceGroup *model_group = st.find_spacegroup();
+    const bool takes_model_group = model_group != nullptr && !coordinates_obey(*model_group, space_group);
+    const gemmi::SpaceGroup &label = takes_model_group ? *model_group : space_group;
+    st.cell = cell;
+    st.spacegroup_hm = label.xhm();
+    st.setup_cell_images();
+    // 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
+    // are written: a convenience deliverable must not be able to take the run's actual output with it.
+    // The map writer does the same.
+    try {
+        gemmi::setup_entities(st);
+        std::ofstream os(cif_path);
+        gemmi::cif::write_cif_to_stream(os, gemmi::make_mmcif_document(st));
+        if (!os) {
+            logger.Error("Model validation: cannot write the placed model to {}", cif_path);
+            return;
+        }
+    } catch (const std::exception &e) {
+        logger.Warning("Model validation: could not write the placed model to {} ({})",
+                       cif_path, e.what());
+        return;
+    }
+    bool pdb_written = false;
+    try {
+        std::ofstream os(pdb_path);
+        gemmi::write_pdb(st, os);
+        pdb_written = static_cast<bool>(os);
+    } catch (const std::exception &e) {
+        logger.Warning("Model validation: the placed model could not also be written as PDB ({}); "
+                       "{} has it", e.what(), cif_path);
+    }
+    if (!takes_model_group) {
+        logger.Info("Model validation: the model as placed against these data written to {}{} "
+                    "(cell and space group {} as in the reflection files)",
+                    cif_path, pdb_written ? " and " + pdb_path : "", space_group.short_name());
+    } else {
+        logger.Warning("Model validation: the model as placed written to {}{} in ITS OWN space group "
+                       "{}, not the {} the reflection files carry - its coordinates do not obey {}, so "
+                       "the two files describe the same crystal in different symmetry and cannot be "
+                       "refined against each other as they stand",
+                       cif_path, pdb_written ? " and " + pdb_path : "",
+                       label.short_name(), space_group.short_name(), space_group.short_name());
+    }
+}