// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only #include "RefinementNewtonGPU.h" #include "RefinementRestraints.h" size_t RestraintNormalMatrixGPU::DeviceBytes(const RestraintSet &set, size_t n_atoms, const std::vector &block_atoms, int iterations) { size_t entries = 0, rows = 0, params = 0, inverse = 0; for (const RestraintRecord &r : set.records) // as At() lays out J switch (static_cast(r.kind)) { case RestraintKind::Plane: entries += static_cast(r.atom[1]) * r.atom[1]; rows += r.atom[1]; break; case RestraintKind::Angle: entries += 3; rows++; break; case RestraintKind::Torsion: case RestraintKind::Chiral: case RestraintKind::NcsDistance: entries += 4; rows++; break; default: entries += 2; rows++; break; } for (int a : block_atoms) { params += a; inverse += static_cast(3 * a) * (3 * a + 1) / 2; } const size_t n = 3 * params; return n_atoms * 4 * sizeof(float) // the positions + set.records.size() * (sizeof(RestraintRecord) + sizeof(int)) + set.plane_atoms.size() * sizeof(int) + rows * (sizeof(int) + 2 * sizeof(float)) // row starts, J v + entries * (8 * sizeof(float) + 3 * sizeof(int)) + params * sizeof(int) // J, its transposed copy, index + n * 15 * sizeof(float) // seven vectors, diagonal + n * (2 * sizeof(float) + 2 * sizeof(int)) + 2 * block_atoms.size() * sizeof(int) // h, the blocks + inverse * 2 * sizeof(float) // their inverses + static_cast(iterations) * n * 3 * sizeof(float); // the kept residuals } // The host half: the index of J, as RestraintGaussNewton lays out its rows, with every row kept. void RestraintNormalMatrixGPU::At(const RestraintSet &set, const std::vector> &xyzb) { if (!indexed_) { std::vector record_entry, start{0}, atom; for (const RestraintRecord &r : set.records) { record_entry.push_back(static_cast(atom.size())); switch (static_cast(r.kind)) { case RestraintKind::Plane: // one row per atom of the plane, each over all of them for (int i = 0; i < r.atom[1]; i++) { for (int k = 0; k < r.atom[1]; k++) atom.push_back(set.plane_atoms[r.atom[0] + k]); start.push_back(static_cast(atom.size())); } continue; case RestraintKind::Angle: atom.insert(atom.end(), r.atom, r.atom + 3); break; case RestraintKind::Torsion: case RestraintKind::Chiral: case RestraintKind::NcsDistance: atom.insert(atom.end(), r.atom, r.atom + 4); break; default: // Bond, Repulsion, BSimilarity atom.insert(atom.end(), r.atom, r.atom + 2); break; } start.push_back(static_cast(atom.size())); } const size_t rows = start.size() - 1; std::vector row_of(atom.size()), param(atom.size()); for (size_t e = 0; e < atom.size(); e++) param[e] = param_of_[atom[e]]; for (size_t r = 0; r < rows; r++) for (int e = start[r]; e < start[r + 1]; e++) row_of[e] = static_cast(r); std::vector entry_start(n_params_ + 1, 0); for (int k : param) if (k >= 0) entry_start[k + 1]++; for (size_t k = 0; k < n_params_; k++) entry_start[k + 1] += entry_start[k]; std::vector entry(entry_start.back()); std::vector fill(entry_start.begin(), entry_start.end() - 1); for (size_t e = 0; e < param.size(); e++) if (param[e] >= 0) entry[fill[param[e]]++] = static_cast(e); Upload(set.records, set.plane_atoms, record_entry, start, param, row_of, entry_start, entry); indexed_ = true; } Fill(xyzb); }