tkmoments_builder.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include "tkmoments_builder.h"
 
#include "json.hpp"
#include "tkcsv.h"
#include "tklog.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <regex>
#include <set>
#include <sstream>
 
using namespace tkn;
using json = nlohmann::json;
 
namespace {
 
std::string trim(const std::string &value)
{
   const auto first = value.find_first_not_of(" \t\r\n");
   if (first == std::string::npos) return "";
   const auto last = value.find_last_not_of(" \t\r\n");
   return value.substr(first, last - first + 1);
}
 
void remove_spaces(std::string &value)
{
   value.erase(
      std::remove_if(value.begin(), value.end(), [](unsigned char character) {
         return std::isspace(character) != 0;
      }),
      value.end());
}
 
void append_tag(std::string &info, const std::string &tag)
{
   if (tag.empty()) return;
   info += ";" + tag;
}
 
double uncertainty_from_digits(const std::string &digits, const std::string &central)
{
   if (digits.find('.') != std::string::npos) return std::stod(digits);
   const auto decimal = central.find('.');
   const int decimal_places = decimal == std::string::npos
      ? 0
      : static_cast<int>(central.size() - decimal - 1);
   return std::stod(digits) * std::pow(10., -decimal_places);
}
 
std::string column_value(const std::vector<std::string> &row,
                         const std::map<std::string, std::size_t> &columns,
                         const std::string &name)
{
   const auto position = columns.find(name);
   if (position == columns.end() || position->second >= row.size()) return "";
   return trim(row[position->second]);
}
 
std::string sqlite_text(sqlite3_stmt *statement, int column)
{
   const auto *value = sqlite3_column_text(statement, column);
   return value ? reinterpret_cast<const char *>(value) : "";
}
 
struct spin_value {
   int numerator = 0;
   int denominator = 1;
};
 
std::string normalized_spin(std::string value)
{
   value = trim(value);
   value.erase(
      std::remove_if(value.begin(), value.end(), [](unsigned char character) {
         return std::isspace(character) || character == '(' || character == ')' ||
                character == '[' || character == ']';
      }),
      value.end());
   std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
      return static_cast<char>(std::tolower(character));
   });
 
   return value;
}
 
bool has_reversed_parity_notation(const std::string &text)
{
   return std::regex_match(trim(text), std::regex(R"(^-\d+(?:/\d+)?$)"));
}
 
bool set_column_value(std::vector<std::string> &row,
                      const std::map<std::string, std::size_t> &columns,
                      const std::string &name,
                      const std::string &value)
{
   const auto position = columns.find(name);
   if (position == columns.end() || position->second >= row.size()) return false;
   row[position->second] = value;
   return true;
}
 
bool repair_reversed_parity_notation(
   std::vector<std::string> &row,
   const std::map<std::string, std::size_t> &columns)
{
   const std::string spin = column_value(row, columns, "spin");
   std::smatch reversed_parity;
   if (!std::regex_match(spin, reversed_parity,
                         std::regex(R"(^-(\d+(?:/\d+)?)$)")))
      return false;
   return set_column_value(row, columns, "spin", reversed_parity[1].str() + "-");
}
 
bool apply_source_correction(std::vector<std::string> &row,
                             const std::map<std::string, std::size_t> &columns,
                             const std::string &source_filename,
                             const std::string &moment_column,
                             const json &corrections,
                             std::string &source_reference)
{
   if (!corrections.is_array()) return false;
   const std::string source_basename =
      std::filesystem::path(source_filename).filename().string();
   for (const auto &correction : corrections) {
      if (!correction.is_object() ||
          correction.value("file", std::string()) != source_basename ||
          correction.value("moment_column", std::string()) != moment_column ||
          !correction.contains("match") || !correction["match"].is_object() ||
          !correction.contains("replace") || !correction["replace"].is_object())
         continue;
 
      auto match_fields = correction["match"].items();
      const bool matches = std::all_of(
         match_fields.begin(), match_fields.end(),
         [&row, &columns](const auto &field) {
            return field.value().is_string() &&
               column_value(row, columns, field.key()) == field.value().template get<std::string>();
         });
      if (!matches) continue;
 
      std::vector<std::string> repaired = row;
      auto replacement_fields = correction["replace"].items();
      if (!std::all_of(
             replacement_fields.begin(), replacement_fields.end(),
             [&repaired, &columns](const auto &field) {
                return field.value().is_string() &&
                   set_column_value(repaired, columns, field.key(),
                                    field.value().template get<std::string>());
             }))
         return false;
      row = std::move(repaired);
      source_reference = correction.value("source_reference", std::string());
      return true;
   }
   return false;
}
 
bool load_source_corrections(const char *filename,
                             json &corrections,
                             std::string &reason)
{
   corrections = json::array();
   if (!filename || !filename[0]) return true;
   std::ifstream input(filename);
   if (!input.good()) {
      reason = std::string("cannot open ") + filename;
      return false;
   }
   try {
      const json document = json::parse(input);
      if (document.value("schema_version", 0) != 1 ||
          !document.contains("corrections") || !document["corrections"].is_array()) {
         reason = std::string("invalid correction-table schema in ") + filename;
         return false;
      }
      corrections = document["corrections"];
   } catch (const std::exception &error) {
      reason = std::string("cannot parse ") + filename + ": " + error.what();
      return false;
   }
   return true;
}
 
bool validate_import_expectations(const std::string &manifest_filename,
                                  int corrected_source_fields,
                                  int alternative_rows,
                                  int incompatible_alternative_rows,
                                  std::string &reason)
{
   if (manifest_filename.empty() ||
       !std::filesystem::is_regular_file(manifest_filename))
      return true;
   try {
      std::ifstream input(manifest_filename);
      const json document = json::parse(input);
      if (!document.contains("import_expectations") ||
          !document["import_expectations"].is_object()) {
         reason = "missing import_expectations in " + manifest_filename;
         return false;
      }
      const auto &expected = document["import_expectations"];
      const std::array<std::pair<const char *, int>, 3> observed{{
         {"corrected_source_fields", corrected_source_fields},
         {"alternative_moment_rows", alternative_rows},
         {"incompatible_alternative_moment_rows", incompatible_alternative_rows},
      }};
      for (const auto &entry : observed) {
         if (!expected.contains(entry.first) ||
             !expected[entry.first].is_number_integer()) {
            reason = std::string("missing integer import expectation '") +
               entry.first + "' in " + manifest_filename;
            return false;
         }
         const int wanted = expected[entry.first].get<int>();
         if (wanted != entry.second) {
            reason = std::string(entry.first) + " changed from " +
               std::to_string(wanted) + " to " + std::to_string(entry.second);
            return false;
         }
      }
   } catch (const std::exception &error) {
      reason = "cannot validate " + manifest_filename + ": " + error.what();
      return false;
   }
   return true;
}
 
template <typename Moment>
double uncertainty_toward(const Moment &moment, bool upward)
{
   if (!moment.has_uncertainty) return -1.;
   if (!moment.asymmetric) return moment.uncertainty;
   return upward ? moment.uncertainty_high : moment.uncertainty_low;
}
 
template <typename Moment>
bool alternatives_are_incompatible(const Moment &first, const Moment &second)
{
   if ((first.value < 0. && second.value > 0.) ||
       (first.value > 0. && second.value < 0.))
      return true;
   const bool second_is_higher = second.value > first.value;
   const double first_error = uncertainty_toward(first, second_is_higher);
   const double second_error = uncertainty_toward(second, !second_is_higher);
   if (first_error < 0. || second_error < 0.) return false;
   const double combined = std::hypot(first_error, second_error);
   return combined > 0. && std::abs(first.value - second.value) > 3. * combined;
}
 
std::vector<spin_value> parse_spin_values(const std::string &text,
                                          int mass,
                                          bool repair_invalid_denominator,
                                          bool &repaired)
{
   std::string value = normalized_spin(text);
   value = std::regex_replace(value, std::regex(R"((\d+)-feb)"), "$1/2");
   value = std::regex_replace(value, std::regex("or"), ",");
   std::replace(value.begin(), value.end(), '|', ',');
 
   const char common_parity = !value.empty() &&
      (value.back() == '+' || value.back() == '-') ? value.back() : '\0';
   std::vector<spin_value> result;
   std::stringstream stream(value);
   std::string alternative;
   const std::regex expression(R"(^(\d+)(?:/(\d+))?([+-]?)$)");
   while (std::getline(stream, alternative, ',')) {
      if (alternative.empty()) continue;
      if (common_parity && alternative.back() != '+' && alternative.back() != '-')
         alternative += common_parity;
      std::smatch match;
      if (!std::regex_match(alternative, match, expression)) continue;
      spin_value parsed;
      parsed.numerator = std::stoi(match[1].str());
      parsed.denominator = match[2].matched ? std::stoi(match[2].str()) : 1;
 
      // Odd-A nuclei have half-integer spin. The Stone value 39/3 for 215Fr
      // is therefore non-physical and can be tested as a denominator-3 to
      // denominator-2 transcription error when the corrected value identifies
      // one adopted level.
      if (repair_invalid_denominator && mass % 2 != 0 &&
          parsed.denominator == 3 && parsed.numerator % 2 != 0) {
         parsed.denominator = 2;
         repaired = true;
      }
      result.push_back(parsed);
   }
   return result;
}
 
bool same_spin_magnitude(const std::string &source,
                         const std::string &target,
                         int mass,
                         bool &repaired)
{
   bool source_repaired = false;
   bool target_repaired = false;
   const auto source_values = parse_spin_values(source, mass, true, source_repaired);
   const auto target_values = parse_spin_values(target, mass, false, target_repaired);
   const bool matches = std::any_of(
      source_values.begin(), source_values.end(),
      [&target_values](const auto &left) {
         return std::any_of(
            target_values.begin(), target_values.end(),
            [&left](const auto &right) {
               return left.numerator * right.denominator ==
                  right.numerator * left.denominator;
            });
      });
   if (matches) repaired = source_repaired;
   return matches;
}
 
enum class lifetime_kind { unknown, finite, stable };
 
struct lifetime_value {
   lifetime_kind kind = lifetime_kind::unknown;
   double seconds = 0.;
   char relation = '=';
};
 
std::string normalize_lifetime_unit(std::string unit)
{
   std::transform(unit.begin(), unit.end(), unit.begin(), [](unsigned char character) {
      return static_cast<char>(std::tolower(character));
   });
   std::size_t position = 0;
   while ((position = unit.find("\xC2\xB5", position)) != std::string::npos)
      unit.replace(position, 2, "u");
   position = 0;
   while ((position = unit.find("\xCE\xBC", position)) != std::string::npos)
      unit.replace(position, 2, "u");
   return unit;
}
 
double time_unit_seconds(const std::string &unit)
{
   if (unit == "ys") return 1.e-24;
   if (unit == "zs") return 1.e-21;
   if (unit == "as") return 1.e-18;
   if (unit == "fs") return 1.e-15;
   if (unit == "ps") return 1.e-12;
   if (unit == "ns") return 1.e-9;
   if (unit == "us") return 1.e-6;
   if (unit == "ms") return 1.e-3;
   if (unit == "s") return 1.;
   if (unit == "m" || unit == "min") return 60.;
   if (unit == "h") return 3600.;
   if (unit == "d") return 86400.;
   if (unit == "y") return 31557600.;
   return 0.;
}
 
lifetime_value parse_source_lifetime(const std::string &text)
{
   lifetime_value result;
   std::string value = trim(text);
   std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
      return static_cast<char>(std::tolower(character));
   });
   if (value.empty() || value == "-") return result;
   if (value == "stable") {
      result.kind = lifetime_kind::stable;
      return result;
   }
 
   const std::regex expression(
      R"(^\s*([<>~]?)([0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[xX]10\^?([+-]?\d+))?(?:\‍([^)]*\))?\s*([A-Za-z\xC2\xB5\xCE\xBC]+))");
   std::smatch match;
   if (!std::regex_search(value, match, expression)) return result;
   try {
      double numeric = std::stod(match[2].str());
      if (match[3].matched) numeric *= std::pow(10., std::stoi(match[3].str()));
      const double multiplier = time_unit_seconds(normalize_lifetime_unit(match[4].str()));
      if (multiplier <= 0.) return result;
      result.kind = lifetime_kind::finite;
      result.seconds = numeric * multiplier;
      result.relation = match[1].str().empty() || match[1].str() == "~"
         ? '=' : match[1].str()[0];
   } catch (...) {
      return lifetime_value{};
   }
   return result;
}
 
lifetime_value candidate_lifetime(double value,
                                   const std::string &unit_text,
                                   bool has_value,
                                   bool stable)
{
   lifetime_value result;
   if (stable) {
      result.kind = lifetime_kind::stable;
      return result;
   }
   if (!has_value) return result;
   const std::string unit = normalize_lifetime_unit(trim(unit_text));
   const double multiplier = time_unit_seconds(unit);
   if (multiplier > 0.) {
      result.kind = lifetime_kind::finite;
      result.seconds = value * multiplier;
      return result;
   }
 
   double energy_multiplier = 0.;
   if (unit == "ev") energy_multiplier = 1.;
   if (unit == "kev") energy_multiplier = 1.e3;
   if (unit == "mev") energy_multiplier = 1.e6;
   if (energy_multiplier > 0. && value > 0.) {
      constexpr double hbar_eV_seconds = 6.582119569e-16;
      result.kind = lifetime_kind::finite;
      result.seconds = hbar_eV_seconds * std::log(2.) / (value * energy_multiplier);
   }
   return result;
}
 
bool compatible_lifetimes(const std::string &source,
                          double candidate_value,
                          const std::string &candidate_unit,
                          bool candidate_has_value,
                          bool candidate_stable)
{
   const auto left = parse_source_lifetime(source);
   const auto right = candidate_lifetime(
      candidate_value, candidate_unit, candidate_has_value, candidate_stable);
   if (left.kind == lifetime_kind::unknown || right.kind == lifetime_kind::unknown)
      return false;
   if (left.kind == lifetime_kind::stable || right.kind == lifetime_kind::stable)
      return left.kind == right.kind;
   if (left.seconds <= 0. || right.seconds <= 0.) return false;
   if (left.relation == '>') return right.seconds >= left.seconds / 2.;
   if (left.relation == '<') return right.seconds <= left.seconds * 2.;
   const double ratio = std::max(left.seconds / right.seconds,
                                 right.seconds / left.seconds);
   return ratio <= 2. + 1.e-12;
}
 
} // namespace
 
tkmoments_builder::tkmoments_builder(tkdatabase *_database) : fDataBase(_database) {}
 
int tkmoments_builder::fill_database(const char *_magnetic_filename,
                                     const char *_quadrupole_filename,
                                     int _only_charge,
                                     int _only_mass)
{
   const std::filesystem::path magnetic_path(_magnetic_filename);
   const std::filesystem::path quadrupole_path(_quadrupole_filename);
   if (magnetic_path.parent_path() == quadrupole_path.parent_path()) {
      const std::filesystem::path corrections =
         magnetic_path.parent_path() / "source-corrections.json";
      if (std::filesystem::is_regular_file(corrections)) {
         const std::string filename = corrections.string();
         return fill_database(
            _magnetic_filename, _quadrupole_filename, _only_charge, _only_mass,
            filename.c_str());
      }
   }
   return fill_database(
      _magnetic_filename, _quadrupole_filename, _only_charge, _only_mass,
      nullptr);
}
 
int tkmoments_builder::fill_database(const char *_magnetic_filename,
                                     const char *_quadrupole_filename,
                                     int _only_charge,
                                     int _only_mass,
                                     const char *_corrections_filename)
{
   fImportedGroundStates = 0;
   fImportedLevels = 0;
   fSkippedValues = 0;
   fUnmatchedLevels = 0;
   fSourceRows = 0;
   fLevelCandidateRows = 0;
   fPhysicallyForbidden = 0;
   fRelaxedLevelMatches = 0;
   fParityRelaxedMatches = 0;
   fRepairedSpinMatches = 0;
   fCorrectedSourceFields = 0;
   fAlternativeMomentRows = 0;
   fIncompatibleAlternativeMomentRows = 0;
 
   if (!fDataBase || !fDataBase->get_sql_db() || !load_targets()) return 1;
 
   fDataBase->exec_sql("BEGIN TRANSACTION");
   if (!clear_existing_moments(_only_charge, _only_mass)) {
      fDataBase->exec_sql("ROLLBACK");
      return 1;
   }
   const int magnetic_status = import_file(
      _magnetic_filename,
      "magnetic dipole [nm]",
      "magnetic_dipole",
      "mun",
      _only_charge,
      _only_mass,
      _corrections_filename);
   const int quadrupole_status = import_file(
      _quadrupole_filename,
      "electric quadrupole [b]",
      "electric_quadrupole",
      "barn",
      _only_charge,
      _only_mass,
      _corrections_filename);
 
   if (magnetic_status || quadrupole_status) {
      fDataBase->exec_sql("ROLLBACK");
      return 1;
   }
 
   if (fSourceRows >= 100 && fSkippedValues * 100 > fSourceRows * 2) {
      glog << error << "Rejected " << fSkippedValues << " of " << fSourceRows
           << " Stone rows (>2%); refusing to publish a partially parsed source"
           << do_endl;
      fDataBase->exec_sql("ROLLBACK");
      return 1;
   }
   if (fHasLevelTable && fLevelCandidateRows >= 100 &&
       fUnmatchedLevels * 100 > fLevelCandidateRows * 10) {
      glog << error << "Could not match " << fUnmatchedLevels << " of "
           << fLevelCandidateRows
           << " Stone level candidates (>10%); refusing the import" << do_endl;
      fDataBase->exec_sql("ROLLBACK");
      return 1;
   }
   if (!_only_charge && !_only_mass) {
      const std::filesystem::path magnetic_path(_magnetic_filename);
      const std::filesystem::path quadrupole_path(_quadrupole_filename);
      if (magnetic_path.parent_path() == quadrupole_path.parent_path()) {
         std::string expectation_error;
         const std::string manifest =
            (magnetic_path.parent_path() / "fallback-manifest.json").string();
         if (!validate_import_expectations(
                manifest, fCorrectedSourceFields, fAlternativeMomentRows,
                fIncompatibleAlternativeMomentRows, expectation_error)) {
            glog << error << "IAEA/Stone import contract changed: "
                 << expectation_error << "; refusing the import until reviewed"
                 << do_endl;
            fDataBase->exec_sql("ROLLBACK");
            return 1;
         }
      }
   }
   fDataBase->exec_sql("END TRANSACTION");
 
   glog << info << "Imported IAEA/Stone moments: "
        << fImportedGroundStates << " ground-state properties and "
        << fImportedLevels << " adopted-level properties" << do_endl;
   if (fSkippedValues > 0)
      glog << warning << fSkippedValues
           << " Stone moment rows have a non-scalar or invalid value and were skipped"
           << do_endl;
   if (fUnmatchedLevels > 0)
      glog << warning << fUnmatchedLevels
           << " Stone moment rows could not be matched unambiguously to an ENSDF adopted level"
           << do_endl;
   if (fPhysicallyForbidden > 0)
      glog << warning << fPhysicallyForbidden
           << " physically forbidden static-moment assignments were rejected"
           << do_endl;
   if (fRelaxedLevelMatches > 0)
      glog << info << fRelaxedLevelMatches
           << " Stone moment rows were matched by the guarded energy/lifetime fallback; "
           << fParityRelaxedMatches << " ignored a superseded parity assignment"
           << do_endl;
   if (fRepairedSpinMatches > 0)
      glog << warning << fRepairedSpinMatches
           << (fRepairedSpinMatches == 1
                  ? " malformed Stone spin assignment was conservatively repaired for matching"
                  : " malformed Stone spin assignments were conservatively repaired for matching")
           << do_endl;
   if (fCorrectedSourceFields > 0)
      glog << info << fCorrectedSourceFields
           << " narrowly identified IAEA/Stone source defects were detected and repaired"
           << do_endl;
   if (fAlternativeMomentRows > 0)
      glog << info << fAlternativeMomentRows
           << " alternative IAEA/Stone moment rows retained their first value as uncertain; "
              "all alternatives remain in the property provenance"
           << do_endl;
   if (fIncompatibleAlternativeMomentRows > 0)
      glog << warning << fIncompatibleAlternativeMomentRows
           << " alternative IAEA/Stone moment rows contain opposite-sign or >3-sigma solutions"
           << do_endl;
 
   return 0;
}
 
bool tkmoments_builder::clear_existing_moments(int _only_charge, int _only_mass) const
{
   std::string filter;
   if (_only_charge)
      filter += " AND e.charge=" + std::to_string(_only_charge);
   if (_only_mass)
      filter += " AND i.mass=" + std::to_string(_only_mass);
 
   const std::string isotope_ids =
      "SELECT i.isotope_id FROM isotope i "
      "JOIN element e ON e.element_id=i.element_id WHERE 1=1" + filter;
   const std::string clear_isotopes =
      "UPDATE isotope SET "
      "magnetic_dipole=NULL,magnetic_dipole_unit=NULL,magnetic_dipole_unc=NULL,"
      "magnetic_dipole_unc_low=NULL,magnetic_dipole_unc_high=NULL,magnetic_dipole_info=NULL,"
      "electric_quadrupole=NULL,electric_quadrupole_unit=NULL,electric_quadrupole_unc=NULL,"
      "electric_quadrupole_unc_low=NULL,electric_quadrupole_unc_high=NULL,electric_quadrupole_info=NULL "
      "WHERE isotope_id IN (" + isotope_ids + ")";
   if (fDataBase->exec_sql(clear_isotopes.c_str()) != SQLITE_OK) return false;
 
   if (!fDataBase->has_table("LEVEL")) return true;
   const std::string clear_levels =
      "UPDATE level SET "
      "level_magnetic_dipole=NULL,level_magnetic_dipole_unit=NULL,level_magnetic_dipole_unc=NULL,"
      "level_magnetic_dipole_unc_low=NULL,level_magnetic_dipole_unc_high=NULL,level_magnetic_dipole_info=NULL,"
      "level_electric_quadrupole=NULL,level_electric_quadrupole_unit=NULL,level_electric_quadrupole_unc=NULL,"
      "level_electric_quadrupole_unc_low=NULL,level_electric_quadrupole_unc_high=NULL,level_electric_quadrupole_info=NULL "
      "WHERE isotope_id IN (" + isotope_ids + ")";
   return fDataBase->exec_sql(clear_levels.c_str()) == SQLITE_OK;
}
 
bool tkmoments_builder::load_targets()
{
   fHasLevelTable = false;
   fIsotopeIds.clear();
   fIsotopeStable.clear();
   fAdoptedLevels.clear();
   fLevelSpins.clear();
 
   sqlite3 *database = fDataBase->get_sql_db();
   sqlite3_stmt *statement = nullptr;
   const char *isotope_sql =
      "SELECT e.charge, i.mass, i.isotope_id, COALESCE(i.lifetime_info,'') "
      "FROM isotope i JOIN element e ON e.element_id=i.element_id";
   if (sqlite3_prepare_v2(database, isotope_sql, -1, &statement, nullptr) != SQLITE_OK)
      return false;
   while (sqlite3_step(statement) == SQLITE_ROW) {
      const nucleus_key nucleus{
         sqlite3_column_int(statement, 0), sqlite3_column_int(statement, 1)};
      fIsotopeIds[nucleus] = sqlite3_column_int(statement, 2);
      fIsotopeStable[nucleus] = sqlite_text(statement, 3).find(";STABLE") != std::string::npos;
   }
   sqlite3_finalize(statement);
 
   if (!fDataBase->has_table("LEVEL") || !fDataBase->has_table("DATASET")) return true;
   fHasLevelTable = true;
 
   const char *level_sql =
      "SELECT e.charge, i.mass, l.level_id, l.level_energy, "
      "COALESCE(l.level_energy_info,''), COALESCE(l.level_spin_parity,''), "
      "l.level_lifetime, COALESCE(l.level_lifetime_unit,''), "
      "COALESCE(l.level_lifetime_info,'') "
      "FROM level l "
      "JOIN dataset d ON d.dataset_id=l.dataset_id "
      "JOIN isotope i ON i.isotope_id=l.isotope_id "
      "JOIN element e ON e.element_id=i.element_id "
      "WHERE d.dataset_source='ENSDF' "
      "AND d.dataset_name LIKE '%ADOPTED LEVELS%'";
   if (sqlite3_prepare_v2(database, level_sql, -1, &statement, nullptr) != SQLITE_OK)
      return false;
 
   while (sqlite3_step(statement) == SQLITE_ROW) {
      level_candidate candidate;
      candidate.id = sqlite3_column_int(statement, 2);
      candidate.energy = sqlite3_column_double(statement, 3);
      const std::string energy_info = sqlite_text(statement, 4);
      const std::string marker = ";OFF=";
      const auto offset_position = energy_info.find(marker);
      if (offset_position != std::string::npos && offset_position + marker.size() < energy_info.size())
         candidate.offset = std::string(1, static_cast<char>(std::toupper(
            static_cast<unsigned char>(energy_info[offset_position + marker.size()]))));
      candidate.spin_parity = sqlite_text(statement, 5);
      fLevelSpins[candidate.id] = candidate.spin_parity;
      candidate.has_lifetime = sqlite3_column_type(statement, 6) != SQLITE_NULL;
      if (candidate.has_lifetime) candidate.lifetime = sqlite3_column_double(statement, 6);
      candidate.lifetime_unit = sqlite_text(statement, 7);
      candidate.stable = sqlite_text(statement, 8).find(";STABLE") != std::string::npos;
      fAdoptedLevels[{sqlite3_column_int(statement, 0), sqlite3_column_int(statement, 1)}]
         .push_back(candidate);
   }
   sqlite3_finalize(statement);
   return true;
}
 
int tkmoments_builder::import_file(const char *_filename,
                                   const std::string &_moment_column,
                                   const std::string &_property_name,
                                   const std::string &_unit,
                                   int _only_charge,
                                   int _only_mass,
                                   const char *_corrections_filename)
{
   std::ifstream input(_filename);
   if (!input.good()) {
      glog << error << "IAEA/Stone moment file cannot be opened: " << _filename << do_endl;
      return 1;
   }
 
   std::string line;
   if (!std::getline(input, line)) return 1;
   std::vector<std::string> header;
   if (!detail::parse_csv_row(line, header)) return 1;
   std::map<std::string, std::size_t> columns;
   for (std::size_t index = 0; index < header.size(); ++index)
      columns[trim(header[index])] = index;
 
   const std::vector<std::string> required = {
      "z", "n.n+n.z", "energy [keV]", "spin", _moment_column,
      "method", "nsr", "indc"};
   const auto missing_column = std::find_if(
      required.begin(), required.end(),
      [&columns](const auto &name) { return !columns.count(name); });
   if (missing_column != required.end()) {
      glog << error << "Invalid IAEA/Stone CSV header in " << _filename
           << ": missing column '" << *missing_column << "'" << do_endl;
      return 1;
   }
 
   json corrections;
   std::string correction_error;
   if (!load_source_corrections(
          _corrections_filename, corrections, correction_error)) {
      glog << error << "Invalid IAEA/Stone source-correction table: "
           << correction_error << do_endl;
      return 1;
   }
 
   int line_number = 1;
   std::set<std::string> seen_source_states;
   while (std::getline(input, line)) {
      ++line_number;
      ++fSourceRows;
      std::vector<std::string> row;
      if (!detail::parse_csv_row(line, row) || row.size() != header.size()) {
         ++fSkippedValues;
         glog << warning << _filename << ":" << line_number
              << ": CSV row width does not match the header" << do_endl;
         continue;
      }
 
      const int charge = std::atoi(column_value(row, columns, "z").c_str());
      const int mass = std::atoi(column_value(row, columns, "n.n+n.z").c_str());
      if ((_only_charge && charge != _only_charge) || (_only_mass && mass != _only_mass))
         continue;
 
      const nucleus_key nucleus{charge, mass};
      const auto isotope = fIsotopeIds.find(nucleus);
      if (isotope == fIsotopeIds.end()) continue;
 
      const std::string raw_source_spin = column_value(row, columns, "spin");
      const std::string raw_source_moment = column_value(row, columns, _moment_column);
      std::string source_fix;
      std::string source_reference;
      if (apply_source_correction(
             row, columns, _filename, _moment_column, corrections,
             source_reference)) {
         source_fix = "CSV_ALIGNMENT";
         ++fCorrectedSourceFields;
      }
      if (has_reversed_parity_notation(raw_source_spin)) {
         if (!repair_reversed_parity_notation(row, columns)) {
            ++fSkippedValues;
            glog << warning << _filename << ":" << line_number
                 << ": failed to repair reversed spin/parity notation '"
                 << raw_source_spin << "'" << do_endl;
            continue;
         }
         if (!source_fix.empty()) source_fix += ",";
         source_fix += "SPIN_PARITY_ORDER";
         ++fCorrectedSourceFields;
      }
 
      const std::string source_state_key =
         std::to_string(charge) + ":" + std::to_string(mass) + ":" +
         column_value(row, columns, "energy [keV]");
      if (!seen_source_states.insert(source_state_key).second) {
         glog << warning << _filename << ":" << line_number
              << ": duplicate Stone state key Z=" << charge << ", A=" << mass
              << ", E='" << column_value(row, columns, "energy [keV]")
              << "'; lifetime/spin matching will decide whether it is distinct"
              << do_endl;
      }
 
      const std::string moment_text = column_value(row, columns, _moment_column);
      // Some IAEA tables contain placeholder rows with state metadata but no
      // recommended moment (currently 124I). This is an ordinary absence, not
      // a malformed value and therefore does not warrant a warning.
      if (moment_text.empty()) continue;
 
      parsed_moment moment = parse_moment(moment_text);
      if (!moment.valid) {
         ++fSkippedValues;
         glog << warning << _filename << ":" << line_number
              << ": skipped non-scalar or invalid moment for Z=" << charge
              << ", A=" << mass << ": '"
              << moment_text << "'" << do_endl;
         continue;
      }
      if (!moment.source_fix.empty()) {
         if (!source_fix.empty()) source_fix += ",";
         source_fix += moment.source_fix;
         ++fCorrectedSourceFields;
      }
      if (!moment.alternative.empty())
         ++fAlternativeMomentRows;
      if (moment.alternative_incompatible) {
         ++fIncompatibleAlternativeMomentRows;
         glog << warning << _filename << ":" << line_number
              << ": incompatible alternative moment solutions for Z=" << charge
              << ", A=" << mass << ": '" << raw_source_moment << "'"
              << do_endl;
      }
 
      ++fLevelCandidateRows;
      const parsed_energy energy = parse_energy(column_value(row, columns, "energy [keV]"));
      if (!energy.valid) {
         ++fUnmatchedLevels;
         glog << warning << _filename << ":" << line_number
              << ": invalid or non-numeric level energy for Z=" << charge
              << ", A=" << mass << ": '"
              << column_value(row, columns, "energy [keV]") << "'" << do_endl;
         continue;
      }
 
      std::string provenance = moment.info;
      append_tag(provenance, "SRC=STONE");
      append_tag(provenance, "NSR=" + column_value(row, columns, "nsr"));
      append_tag(provenance, "INDC=" + column_value(row, columns, "indc"));
      append_tag(provenance, "METHOD=" + column_value(row, columns, "method"));
      append_tag(provenance, "RAW=" + raw_source_moment);
      if (!source_fix.empty()) append_tag(provenance, "SRCFIX=" + source_fix);
      if (!source_reference.empty())
         append_tag(provenance, "SRCREF=" + source_reference);
      if (has_reversed_parity_notation(raw_source_spin))
         append_tag(provenance, "RAW_SPIN=" + raw_source_spin);
 
      const level_match matched_level = fHasLevelTable
         ? find_level(
              nucleus, energy, column_value(row, columns, "spin"),
              column_value(row, columns, "halflife"))
         : level_match{};
      const int level_id = matched_level.id;
      if (!matched_level.method.empty()) {
         if (provenance.find("RAW_SPIN=") == std::string::npos)
            append_tag(provenance, "RAW_SPIN=" + raw_source_spin);
         append_tag(provenance, "MATCH=" + matched_level.method);
         ++fRelaxedLevelMatches;
         if (matched_level.method == "J_ONLY") ++fParityRelaxedMatches;
         if (matched_level.method == "SPIN_REPAIR") {
            ++fRepairedSpinMatches;
            glog << warning << _filename << ":" << line_number
                 << ": repaired non-physical Stone spin '"
                 << column_value(row, columns, "spin") << "' while matching ENSDF spin '"
                 << matched_level.adopted_spin << "' at Z=" << charge << ", A=" << mass
                 << do_endl;
         }
      }
      level_candidate ground_state;
      ground_state.stable = fIsotopeStable[nucleus];
      if (energy.offset.empty() && std::abs(energy.value) < 1.e-9 &&
          lifetime_matches(column_value(row, columns, "halflife"), ground_state)) {
         std::string ground_spin = column_value(row, columns, "spin");
         const auto adopted_spin = fLevelSpins.find(level_id);
         if (adopted_spin != fLevelSpins.end()) ground_spin = adopted_spin->second;
         if (!static_moment_allowed(_property_name, ground_spin)) {
            ++fPhysicallyForbidden;
            glog << warning << _filename << ":" << line_number
                 << ": physically forbidden " << _property_name
                 << " for ground-state spin '" << ground_spin
                 << "' at Z=" << charge << ", A=" << mass << do_endl;
         } else if (update_measure("ISOTOPE", _property_name, "isotope_id",
                                   isotope->second, moment, _unit, provenance)) {
            ++fImportedGroundStates;
         }
      }
 
      // An isotope-only database has no LEVEL table. Ground-state properties
      // are still imported, but excited-state matching is deliberately skipped.
      if (!fHasLevelTable) continue;
 
      if (level_id < 0) {
         ++fUnmatchedLevels;
         glog << warning << _filename << ":" << line_number
              << ": no unambiguous ENSDF adopted-level match for Z=" << charge
              << ", A=" << mass << ", E='"
              << column_value(row, columns, "energy [keV]") << "', spin='"
              << column_value(row, columns, "spin") << "'" << do_endl;
         continue;
      }
      const auto target_spin = fLevelSpins.find(level_id);
      if (target_spin != fLevelSpins.end() &&
          !static_moment_allowed(_property_name, target_spin->second)) {
         ++fPhysicallyForbidden;
         glog << warning << _filename << ":" << line_number
              << ": physically forbidden " << _property_name
              << " for ENSDF spin '" << target_spin->second
              << "' at Z=" << charge << ", A=" << mass << do_endl;
         continue;
      }
      if (update_measure("LEVEL", "level_" + _property_name, "level_id",
                         level_id, moment, _unit, provenance))
         ++fImportedLevels;
   }
   return 0;
}
 
tkmoments_builder::parsed_energy tkmoments_builder::parse_energy(const std::string &_text)
{
   parsed_energy result;
   std::string value = trim(_text);
   remove_spaces(value);
   std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
      return static_cast<char>(std::tolower(character));
   });
 
   if (value.empty() || value == "-" || value.front() == '~' ||
       value.find('<') != std::string::npos || value.find('>') != std::string::npos)
      return result;
 
   std::smatch shifted;
   const std::regex shifted_expression(R"(^([+-]?(?:\d+(?:\.\d*)?|\.\d+))\+([a-z])$)");
   const std::regex numeric_expression(R"(^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$)");
   try {
      if (std::regex_match(value, shifted, shifted_expression)) {
         result.value = std::stod(shifted[1].str());
         result.offset = std::string(1, static_cast<char>(std::toupper(
            static_cast<unsigned char>(shifted[2].str()[0]))));
      } else if (std::regex_match(value, numeric_expression)) {
         result.value = std::stod(value);
      } else {
         return result;
      }
   } catch (...) {
      return result;
   }
   result.valid = true;
   return result;
}
 
tkmoments_builder::parsed_moment tkmoments_builder::parse_moment(const std::string &_text)
{
   parsed_moment result;
   std::string value = trim(_text);
   if (value.empty()) return result;
 
   // "or" denotes discrete solutions of the experimental analysis, not
   // independent measurements that may be averaged. TkN's scalar API keeps
   // the first published solution, marks it uncertain, and preserves the
   // alternative and complete raw field in the provenance.
   const auto alternative_position = value.find(" or ");
   if (alternative_position != std::string::npos) {
      const std::string alternative = trim(value.substr(alternative_position + 4));
      result = parse_moment(value.substr(0, alternative_position));
      const parsed_moment second = parse_moment(alternative);
      if (!result.valid || !second.valid || alternative.empty() ||
          result.info.find("ERR=") != std::string::npos ||
          result.info.find("VAL=()") != std::string::npos)
         return parsed_moment{};
      result.alternative = alternative;
      result.alternative_incompatible =
         alternatives_are_incompatible(result, second);
      append_tag(result.info, "ERR=?");
      append_tag(result.info, "ALT=" + alternative);
      if (result.alternative_incompatible)
         append_tag(result.info, "ALT_INCOMPATIBLE=1");
      return result;
   }
 
   if (value.front() == '\'') value.erase(value.begin());
   if (value.rfind("Ref. estimated ", 0) == 0) {
      value.erase(0, 15);
      append_tag(result.info, "ERR=CA");
   } else if (value.rfind("estimated ", 0) == 0) {
      value.erase(0, 10);
      append_tag(result.info, "ERR=CA");
   }
 
   const std::regex spin_prefix(R"(^\‍(I\s*=\s*[^)]+\)\s*)");
   const std::regex spin_suffix(R"(\s*\‍(I\s*=\s*[^)]+\)\s*$)");
   value = std::regex_replace(value, spin_prefix, "");
   value = std::regex_replace(value, spin_suffix, "");
 
   if (value.size() > 1 && value.front() == '[' && value.back() == ']') {
      value = value.substr(1, value.size() - 2);
      append_tag(result.info, "ERR=CA");
   }
 
   if (value.rfind("(+)", 0) == 0 || value.rfind("(-)", 0) == 0) {
      const char sign = value[1];
      value = sign + value.substr(3);
      append_tag(result.info, "VAL=()");
   }
 
   if (!value.empty() && (value.front() == '<' || value.front() == '>')) {
      append_tag(result.info, value.front() == '<' ? "ERR=LT" : "ERR=GT");
      value.erase(value.begin());
   }
   remove_spaces(value);
 
   // Repair only syntax errors for which a unique one-character correction
   // produces a standard Stone value. These patterns cover the currently
   // identified duplicated/misplaced parenthesis and the truncated closing
   // parenthesis of an asymmetric uncertainty.
   bool repaired_syntax = false;
   const auto duplicated_parenthesis = value.find("((");
   if (duplicated_parenthesis != std::string::npos &&
       value.find("((", duplicated_parenthesis + 2) == std::string::npos) {
      value.erase(duplicated_parenthesis, 1);
      repaired_syntax = true;
   }
 
   std::smatch misplaced_uncertainty;
   const std::regex misplaced_uncertainty_expression(
      R"(^([+-]?(?:\d+(?:\.\d*)?|\.\d+))\)([0-9]+(?:\.[0-9]+)?)\)$)");
   if (std::regex_match(value, misplaced_uncertainty,
                        misplaced_uncertainty_expression)) {
      value = misplaced_uncertainty[1].str() + "(" +
         misplaced_uncertainty[2].str() + ")";
      repaired_syntax = true;
   }
 
   // This exact IAEA truncation is independently corroborated by Table 1 of
   // the same authors' KISS report (2021), which gives
   // mu(198Ir)=+0.13(+0.10/-0.02) mu_N and cites 2020Mu16. Do not generalize
   // the repair: another truncated final digit would not be uniquely known.
   if (value == "+0.13(+10,-2") {
      value += ")";
      repaired_syntax = true;
   }
   if (repaired_syntax) result.source_fix = "MOMENT_SYNTAX";
 
   std::smatch match;
   const std::regex asymmetric_expression(
      R"(^([+-]?(?:\d+(?:\.\d*)?|\.\d+))\‍(\+([0-9]+(?:\.[0-9]+)?)[,/]?-([0-9]+(?:\.[0-9]+)?)\)$)");
   const std::regex symmetric_expression(
      R"(^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(?:\‍(([0-9]+(?:\.[0-9]+)?)\))?([A-Za-z#*?]*)$)");
 
   try {
      if (std::regex_match(value, match, asymmetric_expression)) {
         const std::string central = match[1].str();
         result.value = std::stod(central);
         result.uncertainty_high = uncertainty_from_digits(match[2].str(), central);
         result.uncertainty_low = uncertainty_from_digits(match[3].str(), central);
         result.asymmetric = true;
         result.has_uncertainty = true;
      } else if (std::regex_match(value, match, symmetric_expression)) {
         const std::string central = match[1].str();
         result.value = std::stod(central);
         if (match[2].matched) {
            result.uncertainty = uncertainty_from_digits(match[2].str(), central);
            result.has_uncertainty = true;
         } else if (result.info.find("ERR=LT") == std::string::npos &&
                    result.info.find("ERR=GT") == std::string::npos) {
            append_tag(result.info, "ERR=?");
         }
         if (match[3].matched && !match[3].str().empty())
            append_tag(result.info, "NOTE=" + match[3].str());
      } else {
         return result;
      }
   } catch (...) {
      return result;
   }
 
   result.valid = true;
   return result;
}
 
std::string tkmoments_builder::normalize_spin(const std::string &_text)
{
   return normalized_spin(_text);
}
 
bool tkmoments_builder::spin_matches(const std::string &_stone_spin,
                                     const std::string &_ensdf_spin)
{
   auto alternatives = [](std::string value) {
      value = normalize_spin(value);
      value = std::regex_replace(value, std::regex(R"((\d+)-feb)"), "$1/2");
      value = std::regex_replace(value, std::regex("or"), ",");
      std::replace(value.begin(), value.end(), '|', ',');
 
      const char common_parity = !value.empty() &&
         (value.back() == '+' || value.back() == '-') ? value.back() : '\0';
      std::vector<std::string> result;
      std::stringstream stream(value);
      std::string alternative;
      while (std::getline(stream, alternative, ',')) {
         if (alternative.empty()) continue;
         if (common_parity && alternative.back() != '+' && alternative.back() != '-')
            alternative += common_parity;
         result.push_back(alternative);
      }
      return result;
   };
 
   const auto source = alternatives(_stone_spin);
   const auto target = alternatives(_ensdf_spin);
   return std::any_of(source.begin(), source.end(), [&target](const auto &left) {
      return std::any_of(target.begin(), target.end(), [&left](const auto &right) {
         if (left == right) return true;
         const bool left_has_parity = left.back() == '+' || left.back() == '-';
         const bool right_has_parity = right.back() == '+' || right.back() == '-';
         const std::string left_spin = left_has_parity ? left.substr(0, left.size() - 1) : left;
         const std::string right_spin = right_has_parity ? right.substr(0, right.size() - 1) : right;
         return left_spin == right_spin && (!left_has_parity || !right_has_parity);
      });
   });
}
 
bool tkmoments_builder::static_moment_allowed(const std::string &_property_name,
                                              const std::string &_spin)
{
   std::string value = normalize_spin(_spin);
   value = std::regex_replace(value, std::regex("or"), ",");
   std::replace(value.begin(), value.end(), '|', ',');
 
   bool parsed_any = false;
   bool every_alternative_forbidden = true;
   std::stringstream alternatives(value);
   std::string alternative;
   while (std::getline(alternatives, alternative, ',')) {
      if (alternative.empty()) continue;
      if (alternative.back() == '+' || alternative.back() == '-')
         alternative.pop_back();
 
      std::smatch match;
      const std::regex spin_expression(R"(^(\d+)(?:/(\d+))?$)");
      if (!std::regex_match(alternative, match, spin_expression)) return true;
      const double numerator = std::stod(match[1].str());
      const double denominator = match[2].matched ? std::stod(match[2].str()) : 1.;
      if (denominator == 0.) return true;
      const double spin = numerator / denominator;
      parsed_any = true;
      const bool forbidden = _property_name == "magnetic_dipole"
         ? std::abs(spin) < 1.e-12
         : spin < 1.;
      every_alternative_forbidden = every_alternative_forbidden && forbidden;
   }
   return !parsed_any || !every_alternative_forbidden;
}
 
bool tkmoments_builder::lifetime_matches(const std::string &_stone_lifetime,
                                         const level_candidate &_candidate)
{
   std::string lifetime = trim(_stone_lifetime);
   std::transform(lifetime.begin(), lifetime.end(), lifetime.begin(),
      [](unsigned char character) { return static_cast<char>(std::tolower(character)); });
   if (lifetime.empty() || lifetime == "-") return true;
   // Stone may label observationally stable nuclei as "stable" while a newer
   // ENSDF evaluation gives an extremely long finite half-life.
   if (lifetime == "stable") return true;
   // A finite-lived Stone entry cannot denote an ENSDF level marked stable.
   // Numeric lifetimes are otherwise only supporting metadata: the adopted
   // value may have changed between evaluations.
   return !_candidate.stable;
}
 
tkmoments_builder::level_match tkmoments_builder::find_level(
   const nucleus_key &_nucleus,
   const parsed_energy &_energy,
   const std::string &_spin,
   const std::string &_lifetime) const
{
   const auto levels = fAdoptedLevels.find(_nucleus);
   if (levels == fAdoptedLevels.end()) return {};
 
   constexpr double strict_energy_tolerance_keV = 1.;
   std::vector<const level_candidate *> candidates;
   for (const auto &candidate : levels->second) {
      if (!_energy.offset.empty() && candidate.offset != _energy.offset) continue;
      if (std::abs(candidate.energy - _energy.value) <= strict_energy_tolerance_keV &&
          lifetime_matches(_lifetime, candidate))
         candidates.push_back(&candidate);
   }
 
   if (!candidates.empty()) {
      std::vector<const level_candidate *> spin_candidates;
      if (!trim(_spin).empty()) {
         std::copy_if(candidates.begin(), candidates.end(), std::back_inserter(spin_candidates),
            [&](const level_candidate *candidate) {
               return spin_matches(_spin, candidate->spin_parity);
            });
         if (spin_candidates.empty()) {
            std::vector<const level_candidate *> unknown_spin_candidates;
            std::copy_if(candidates.begin(), candidates.end(),
               std::back_inserter(unknown_spin_candidates),
               [](const level_candidate *candidate) {
                  return trim(candidate->spin_parity).empty();
               });
            candidates = unknown_spin_candidates;
         } else {
            candidates = spin_candidates;
         }
      }
 
      // A Stone energy without an explicit band offset normally denotes an
      // absolute ENSDF energy. Prefer it when spin/lifetime leave both absolute
      // and offset-band candidates; otherwise the unique offset match is valid.
      if (_energy.offset.empty()) {
         std::vector<const level_candidate *> absolute_candidates;
         std::copy_if(candidates.begin(), candidates.end(),
            std::back_inserter(absolute_candidates),
            [](const level_candidate *candidate) { return candidate->offset.empty(); });
         if (!absolute_candidates.empty()) candidates = absolute_candidates;
      }
 
      if (candidates.size() == 1)
         return {candidates.front()->id, "", candidates.front()->spin_parity};
 
      if (!candidates.empty()) {
         const auto closest = std::min_element(candidates.begin(), candidates.end(),
            [&](const level_candidate *left, const level_candidate *right) {
               return std::abs(left->energy - _energy.value) <
                      std::abs(right->energy - _energy.value);
            });
         const double closest_difference = std::abs((*closest)->energy - _energy.value);
         const int equally_close = static_cast<int>(std::count_if(
            candidates.begin(), candidates.end(), [&](const level_candidate *candidate) {
               return std::abs(std::abs(candidate->energy - _energy.value) -
                               closest_difference) < 1.e-9;
            }));
         if (equally_close == 1)
            return {(*closest)->id, "", (*closest)->spin_parity};
      }
   }
 
   // Evaluated level energies and parity assignments may change after the
   // moment measurement. Search a wider window only when J and a numerical
   // lifetime identify exactly one adopted level. A missing lifetime is not
   // sufficient for this fallback.
   constexpr double fallback_energy_tolerance_keV = 10.;
   std::vector<const level_candidate *> fallback_candidates;
   bool repaired_spin = false;
   for (const auto &candidate : levels->second) {
      if (!_energy.offset.empty() && candidate.offset != _energy.offset) continue;
      if (std::abs(candidate.energy - _energy.value) > fallback_energy_tolerance_keV)
         continue;
      bool candidate_used_repair = false;
      if (!same_spin_magnitude(
             _spin, candidate.spin_parity, _nucleus.second, candidate_used_repair))
         continue;
      if (!compatible_lifetimes(
             _lifetime, candidate.lifetime, candidate.lifetime_unit,
             candidate.has_lifetime, candidate.stable))
         continue;
      fallback_candidates.push_back(&candidate);
      repaired_spin = repaired_spin || candidate_used_repair;
   }
 
   if (_energy.offset.empty()) {
      std::vector<const level_candidate *> absolute_candidates;
      std::copy_if(fallback_candidates.begin(), fallback_candidates.end(),
         std::back_inserter(absolute_candidates),
         [](const level_candidate *candidate) { return candidate->offset.empty(); });
      if (!absolute_candidates.empty()) fallback_candidates = absolute_candidates;
   }
   if (fallback_candidates.size() != 1) return {};
 
   const auto *candidate = fallback_candidates.front();
   std::string method = "ENERGY_LIFETIME";
   if (repaired_spin)
      method = "SPIN_REPAIR";
   else if (!spin_matches(_spin, candidate->spin_parity))
      method = "J_ONLY";
   return {candidate->id, method, candidate->spin_parity};
}
 
bool tkmoments_builder::update_measure(const std::string &_table,
                                       const std::string &_prefix,
                                       const std::string &_id_column,
                                       int _id,
                                       const parsed_moment &_moment,
                                       const std::string &_unit,
                                       const std::string &_provenance) const
{
   const std::string sql =
      "UPDATE " + _table + " SET " +
      _prefix + "=?1," +
      _prefix + "_unit=?2," +
      _prefix + "_unc=?3," +
      _prefix + "_unc_low=?4," +
      _prefix + "_unc_high=?5," +
      _prefix + "_info=?6 WHERE " + _id_column + "=?7";
 
   sqlite3_stmt *statement = nullptr;
   if (sqlite3_prepare_v2(fDataBase->get_sql_db(), sql.c_str(), -1, &statement, nullptr) != SQLITE_OK)
      return false;
 
   sqlite3_bind_double(statement, 1, _moment.value);
   sqlite3_bind_text(statement, 2, _unit.c_str(), -1, SQLITE_TRANSIENT);
   if (_moment.has_uncertainty && !_moment.asymmetric)
      sqlite3_bind_double(statement, 3, _moment.uncertainty);
   else
      sqlite3_bind_null(statement, 3);
   if (_moment.has_uncertainty && _moment.asymmetric) {
      sqlite3_bind_double(statement, 4, _moment.uncertainty_low);
      sqlite3_bind_double(statement, 5, _moment.uncertainty_high);
   } else {
      sqlite3_bind_null(statement, 4);
      sqlite3_bind_null(statement, 5);
   }
   sqlite3_bind_text(statement, 6, _provenance.c_str(), -1, SQLITE_TRANSIENT);
   sqlite3_bind_int(statement, 7, _id);
 
   const bool success = sqlite3_step(statement) == SQLITE_DONE && sqlite3_changes(fDataBase->get_sql_db()) == 1;
   sqlite3_finalize(statement);
   return success;
}