tkisotope_builder.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include "tkisotope_builder.h"
#include "tkcsv.h"
 
#include <algorithm>
#include <iostream>
#include <fstream>
#include <set>
 
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
using namespace std;
 
namespace {
 
const std::set<std::string> &nudat_nucleus_keys()
{
   static const std::set<std::string> keys{
      "BE4DBE2",
      "a",
      "bindingEnergy",
      "bindingEnergyLDMFit",
      "discovery",
      "excitedStateEnergies",
      "fissionYields",
      "levels",
      "n",
      "name",
      "pairingGap",
      "qValues",
      "quadrupoleDeformation",
      "separationEnergies",
      "thermalNeutronCapture",
      "thermalNeutronFission",
      "webLinks",
      "z",
   };
   return keys;
}
 
const std::set<std::string> &nudat_excited_state_energy_keys()
{
   static const std::set<std::string> keys{
      "firstExcitedStateEnergy",
      "firstFourPlusEnergy",
      "firstFourPlusOverFirstTwoPlusEnergy",
      "firstThreeMinusEnergy",
      "firstTwoPlusEnergy",
      "firstZeroPlusEnergy",
      "secondTwoPlusEnergy",
   };
   return keys;
}
 
bool valid_nudat_scalar(const json &value)
{
   return value.is_string() || value.is_number();
}
 
} // namespace
 
// Decay Mode           : decay modes.
// Mass excess          : Mass excess
// β2                   : quadrupole deformation parameter obtained from the B(E2) value, as explained in the 2001 work of Raman et al. Basically,
//                        β2=(4π/3ZR0^2)[B(E2)]^(1/2), where R0=1.2A^(1/3), Z and A are the number of protons and the number of nucleons respectively,
//                        and the B(E2) values are obtained from ENSDF. B(E2) values can have large uncertainties, or be defined as upper/lower limits.
//                        The cell will not be colored for the latter cases and furthermore, it will not be colored if the uncertainty of the derived β2 exceeds 50%.
// FY235U               : thermal neutron-induced fission yields for 235-Uranium. The fission yields are normalized so that their sum is equal to 2.
// FY238U               : neutron-induced fission yields for 238-Uranium. The fission yields are normalized so that their sum is equal to 2.
// FY239Pu              : thermal neutron-induced fission yields for 239-Plutonium. The fission yields are normalized so that their sum is equal to 2.
// FY241Pu              : neutron-induced fission yields for 241-Plutonium. The fission yields are normalized so that their sum is equal to 2.
// FY252Cf              : spontaneous fission yields for 252-Californium. The fission yields are normalized so that their sum is equal to 2.
// cFY235U              : cumulative fission yields
// cFY238U              : cumulative fission yields
// cFY239Pu             : cumulative fission yields
// cFY241Pu             : cumulative fission yields
// cFY252Cf             : cumulative fission yields
 
tkisotope_builder::tkisotope_builder(tkdatabase *_database, const char *_table_name) : tkdb_builder(_database, _table_name)
{
   fTable = &fDataBase->new_table(fTableName);
 
   fTable->add_column("isotope_id", "INTEGER PRIMARY KEY NOT NULL");
   fTable->add_column("element_id", "INT NOT NULL");
   fTable->add_column("mass", "INT");
 
   // data taken from the primary evaluated/compiled sources
 
   fTable->add_column("isotope_year_discovered", "INT");
 
   add_measure("mass_excess", false);
   add_measure("electric_quadrupole", false);
   add_measure("magnetic_dipole", false);
   add_measure("radius", false);
 
   // data taken from NUDAT3 json file
 
   add_measure("abundance", false);
   add_measure("quadrupoleDeformation", false);
 
   add_measure("FY235U", false);
   add_measure("FY238U", false);
   add_measure("FY239Pu", false);
   add_measure("FY241Pu", false);
   add_measure("FY252Cf", false);
 
   add_measure("cFY235U", false);
   add_measure("cFY238U", false);
   add_measure("cFY239Pu", false);
   add_measure("cFY241Pu", false);
   add_measure("cFY252Cf", false);
 
   fTable->add_column("decay_modes", "TEXT");
 
   // columns created here but filled later by ensdf values
 
   fTable->add_column("spin", "REAL");
   fTable->add_column("parity", "INT");
   fTable->add_column("spin_parity", "TEXT");
 
   add_measure("lifetime", false);
 
   fTable->add_constraint("FOREIGN KEY (element_id) REFERENCES ELEMENT (element_id)"); // hold this link with a constraints
   fTable->write_to_database();
 
   glog << info << "Creating '" << _table_name << "' table" << do_endl;
}
 
tkisotope_builder::~tkisotope_builder() = default;
 
bool tkisotope_builder::validate_nudat_json(const char *_filename,
                                            std::string &_reason)
{
   std::ifstream input(_filename, std::ios::binary);
   if (!input.good()) {
      _reason = "file cannot be opened";
      return false;
   }
 
   try {
      const json document = json::parse(input);
      if (!document.is_object() || document.size() != 1 ||
          !document.contains("nuclides") || !document.at("nuclides").is_array() ||
          document.at("nuclides").empty()) {
         _reason = "expected one non-empty top-level 'nuclides' array";
         return false;
      }
 
      std::size_t index = 0;
      for (const auto &nucleus : document.at("nuclides")) {
         ++index;
         if (!nucleus.is_object()) {
            _reason = "nuclides[" + std::to_string(index - 1) + "] is not an object";
            return false;
         }
 
         const std::string name = nucleus.value("name", std::string("nuclides[") +
                                                std::to_string(index - 1) + "]");
         auto fields = nucleus.items();
         const auto unexpected_field = std::find_if(
            fields.begin(), fields.end(),
            [](const auto &field) { return nudat_nucleus_keys().count(field.key()) == 0; });
         if (unexpected_field != fields.end()) {
            _reason = name + ": unexpected NuDat key '" + unexpected_field.key() + "'";
            return false;
         }
 
         if (!nucleus.contains("name") || !nucleus.at("name").is_string() ||
             !nucleus.contains("z") || !nucleus.at("z").is_number_integer() ||
             !nucleus.contains("n") || !nucleus.at("n").is_number_integer() ||
             !nucleus.contains("a") || !nucleus.at("a").is_number_integer()) {
            _reason = name + ": invalid or missing name/z/n/a identity";
            return false;
         }
         if (nucleus.contains("levels") && !nucleus.at("levels").is_array()) {
            _reason = name + ": 'levels' is not an array";
            return false;
         }
         if (nucleus.contains("fissionYields") &&
             !nucleus.at("fissionYields").is_object()) {
            _reason = name + ": 'fissionYields' is not an object";
            return false;
         }
         if (nucleus.contains("quadrupoleDeformation") &&
             !nucleus.at("quadrupoleDeformation").is_object()) {
            _reason = name + ": 'quadrupoleDeformation' is not an object";
            return false;
         }
         if (nucleus.contains("discovery") && !nucleus.at("discovery").is_object()) {
            _reason = name + ": 'discovery' is not an object";
            return false;
         }
 
         if (!nucleus.contains("excitedStateEnergies")) continue;
         const auto &energies = nucleus.at("excitedStateEnergies");
         if (!energies.is_object()) {
            _reason = name + ": 'excitedStateEnergies' is not an object";
            return false;
         }
         for (const auto &energy : energies.items()) {
            if (nudat_excited_state_energy_keys().count(energy.key()) == 0) {
               _reason = name + ": unexpected excitedStateEnergies key '" +
                  energy.key() + "'";
               return false;
            }
            if (!energy.value().is_object() || !energy.value().contains("value") ||
                !valid_nudat_scalar(energy.value().at("value"))) {
               _reason = name + ": invalid object for excitedStateEnergies.'" +
                  energy.key() + "'";
               return false;
            }
         }
      }
   } catch (const std::exception &exception) {
      _reason = exception.what();
      return false;
   }
 
   _reason.clear();
   return true;
}
 
void tkisotope_builder::fill_isotope(const json_nucleus &_json_nuc)
{
   fIsotopeIdx++;
 
   //    glog << debug << "filling db with : " << _json_nuc.name.data() << " " << fIsotopeIdx<< do_endl;
 
   (*fTable)["isotope_id"].set_value(fIsotopeIdx);
   (*fTable)["element_id"].set_value(_json_nuc.Z + 1);
   (*fTable)["mass"].set_value(_json_nuc.A);
   (*fTable)["isotope_year_discovered"].set_value(_json_nuc.year);
 
   fill_measure("mass_excess", _json_nuc.mass_excess, false);
   fill_measure("abundance", _json_nuc.abundance, false);
   fill_measure("quadrupoleDeformation", _json_nuc.quadrupoleDeformation, false);
 
   fill_measure("FY235U", _json_nuc.FY235U, false);
   fill_measure("FY238U", _json_nuc.FY238U, false);
   fill_measure("FY239Pu", _json_nuc.FY239Pu, false);
   fill_measure("FY241Pu", _json_nuc.FY241Pu, false);
   fill_measure("FY252Cf", _json_nuc.FY252Cf, false);
 
   fill_measure("cFY235U", _json_nuc.cFY235U, false);
   fill_measure("cFY238U", _json_nuc.cFY238U, false);
   fill_measure("cFY239Pu", _json_nuc.cFY239Pu, false);
   fill_measure("cFY241Pu", _json_nuc.cFY241Pu, false);
   fill_measure("cFY252Cf", _json_nuc.cFY252Cf, false);
 
   fill_measure("electric_quadrupole", _json_nuc.electric_quadrupole, false);
   fill_measure("magnetic_dipole", _json_nuc.magnetic_dipole, false);
   fill_measure("radius", _json_nuc.radius, false);
 
   // fill the neutron lifetime
   if (_json_nuc.Z == 0 && _json_nuc.N == 1) {
      tkdb_table::measure_data_struct lifetime;
      lifetime.value = 613.9;
      lifetime.err = 0.6;
      lifetime.unit = "S";
      lifetime.filled = true;
      fill_measure("lifetime", lifetime, false);
   }
 
   tkstring decays;
   for (auto &dec : _json_nuc.decay_modes) decays.append(tkstring::form("[%s;%g]", dec.first.data(), dec.second));
   (*fTable)["decay_modes"].set_value(decays.data());
 
   fTable->push_row();
}
 
int tkisotope_builder::fill_database(const char *_json_filename,
                                     const char *_ame_filename,
                                     const char *_charge_radii_filename,
                                     int _only_charge,
                                     int _only_mass)
{
   glog.set_class("db_isotope_builder");
   glog.set_method(tkstring::form("fill_database('%s','%s','%s')",
                                 _json_filename,
                                 _ame_filename,
                                 _charge_radii_filename));
 
   tkdb_table &fTable = (*fDataBase)[fTableName.data()];
 
   tkstring message = "Building '" + fTable.get_name() + "' table";
 
   std::string nudat_validation_error;
   if (!validate_nudat_json(_json_filename, nudat_validation_error)) {
      glog << error_v << "NuDat JSON failed schema validation: "
           << nudat_validation_error << do_endl;
      glog.clear();
      return 1;
   }
 
   std::ifstream ifs(_json_filename);
   if (!ifs.good()) {
      glog << error_v << "data file cannot be opened" << do_endl;
      glog.clear();
      return 1;
   }
 
   json jf = json::parse(ifs);
 
   auto &nuclides = jf.at("nuclides");
   int NNucs = nuclides.size();
   int inuc = 0;
 
   map<int, map<int, json_nucleus>> nuclei;
 
   for (auto &nuc : nuclides) {
      json_nucleus json_nuc = read_nucleus(nuc);
 
      bool do_push = ((_only_charge == 0) && (_only_mass == 0));
      if ((_only_charge == json_nuc.Z) && (_only_mass == 0)) do_push = true;
      if ((_only_charge == json_nuc.Z) && (_only_mass == json_nuc.A)) do_push = true;
      if ((_only_charge == 0) && (_only_mass == json_nuc.A)) do_push = true;
 
      if (do_push) {
         nuclei[json_nuc.Z][json_nuc.A] = json_nuc;
      }
      glog.progress_bar(NNucs, inuc, message.data());
      inuc++;
   }
 
   auto selected_nucleus = [&nuclei](int z, int a) -> json_nucleus * {
      auto z_it = nuclei.find(z);
      if (z_it == nuclei.end()) return nullptr;
      auto a_it = z_it->second.find(a);
      if (a_it == z_it->second.end()) return nullptr;
      return &a_it->second;
   };
 
   std::ifstream ame_file(_ame_filename);
   if (!ame_file.is_open()) {
      glog << error_v << "AME mass table cannot be opened: '" << _ame_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   // AME2020 fixed-width format:
   // a1,i3,i5,i5,i5,1x,a3,a4,1x,f14.6,f12.6,...
   // A '#' in place of a decimal point marks an estimated value.
   int imported_masses = 0;
   bool ame_header_found = false;
   std::string source_line;
   while (std::getline(ame_file, source_line)) {
      if (source_line.find("MASS EXCESS") != std::string::npos &&
          source_line.find("BINDING ENERGY/A") != std::string::npos) {
         ame_header_found = true;
      }
      if (source_line.size() < 54) continue;
 
      tkstring neutron_field = source_line.substr(4, 5);
      tkstring charge_field = source_line.substr(9, 5);
      tkstring mass_number_field = source_line.substr(14, 5);
      neutron_field.remove_all(" ");
      charge_field.remove_all(" ");
      mass_number_field.remove_all(" ");
      if (neutron_field.is_empty() || charge_field.is_empty() || mass_number_field.is_empty()) continue;
 
      const int z = charge_field.atoi();
      const int a = mass_number_field.atoi();
      if (a <= 0 || z < 0 || z > a) continue;
 
      tkstring mass_excess_field = source_line.substr(28, 14);
      tkstring uncertainty_field = source_line.substr(42, 12);
      tkstring compact_mass_excess = mass_excess_field;
      compact_mass_excess.remove_all(" ");
      if (mass_excess_field.contains("*") || compact_mass_excess.is_empty()) continue;
 
      const bool systematic = mass_excess_field.contains("#") || uncertainty_field.contains("#");
      mass_excess_field.replace_all("#", ".");
      uncertainty_field.replace_all("#", ".");
 
      auto *nucleus = selected_nucleus(z, a);
      if (!nucleus) continue;
      nucleus->mass_excess = {
         mass_excess_field.atof(),
         uncertainty_field.atof(),
         -1., -1., "keV", systematic ? ";ERR=SY" : "", true};
      ++imported_masses;
   }
   if (!ame_header_found ||
       (imported_masses == 0 && _only_charge == 0 && _only_mass == 0)) {
      glog << error_v << "No valid mass excess was read from AME table: '"
           << _ame_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   std::ifstream radii_file(_charge_radii_filename);
   if (!radii_file.is_open()) {
      glog << error_v << "Charge-radii table cannot be opened: '"
           << _charge_radii_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   tkstring line;
   if (!std::getline(radii_file, line)) {
      glog << error_v << "Charge-radii table is empty: '"
           << _charge_radii_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   std::vector<std::string> radius_header;
   if (!detail::parse_csv_row(line.data(), radius_header)) {
      glog << error_v << "Charge-radii CSV header has unmatched quoting: '"
           << _charge_radii_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
   std::map<tkstring, std::size_t> radius_columns;
   for (std::size_t index = 0; index < radius_header.size(); ++index)
      radius_columns[tkstring(radius_header[index])] = index;
   bool has_z = false;
   bool has_a = false;
   bool has_radius = false;
   bool has_radius_uncertainty = false;
   has_z = radius_columns.count("z") != 0;
   has_a = radius_columns.count("a") != 0;
   has_radius = radius_columns.count("radius_val") != 0;
   has_radius_uncertainty = radius_columns.count("radius_unc") != 0;
   if (!has_z || !has_a || !has_radius || !has_radius_uncertainty) {
      glog << error_v << "Charge-radii table has an invalid header: '"
           << _charge_radii_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   int imported_radii = 0;
   int malformed_radius_rows = 0;
   while (std::getline(radii_file, line)) {
      std::vector<std::string> row;
      if (!detail::parse_csv_row(line.data(), row) || row.size() != radius_header.size()) {
         ++malformed_radius_rows;
         continue;
      }
 
      auto value = [&](const tkstring &name) {
         tkstring result = row.at(radius_columns.at(name));
         result.remove_all(" ");
         return result;
      };
      const tkstring radius_value = value("radius_val");
      if (radius_value.is_empty()) continue;
      auto *nucleus = selected_nucleus(value("z").atoi(), value("a").atoi());
      if (!nucleus) continue;
      nucleus->radius = {
         radius_value.atof(),
         value("radius_unc").atof(),
         -1., -1., "fm", "", true};
      ++imported_radii;
   }
   if (malformed_radius_rows > 0) {
      glog << error_v << malformed_radius_rows
           << " charge-radii CSV rows do not match the header width" << do_endl;
      glog.clear();
      return 1;
   }
   if (imported_radii == 0 && _only_charge == 0 && _only_mass == 0) {
      glog << error_v << "No published radius was read from charge-radii table: '"
           << _charge_radii_filename << "'" << do_endl;
      glog.clear();
      return 1;
   }
 
   fDataBase->exec_sql("BEGIN TRANSACTION");
 
   inuc = 0;
   for (const auto &z : nuclei) {
      for (const auto &a : z.second) {
         //            glog << debug << "filling db with : " << a.second.name.data() << do_endl;
 
         fill_isotope(a.second);
         //            json_nuc.print();
         glog.progress_bar(NNucs, inuc, message.data());
         inuc++;
      }
   }
 
   fDataBase->exec_sql("END TRANSACTION");
 
   fDataBase->exec_sql("CREATE INDEX element_mass_index ON isotope(element_id,mass)");
   fDataBase->exec_sql("CREATE INDEX mass_index ON isotope(mass)");
 
   glog.clear();
 
   return 0;
}
 
void tkisotope_builder::read_measure(const tkstring &key, const json &entry, tkdb_table::measure_data_struct &_data, bool _fromstd)
{
   auto to_number = [](const json &value) {
      if (value.is_string()) return value.get<tkstring>().atof();
      if (value.is_number()) return value.get<double>();
      return 0.0;
   };
   bool value_set = false;
   for (auto &_item : entry.items()) {
      const auto &_key = _item.key();
      const auto &_val = _item.value();
      if (_key == "formats") continue;
      if (_key == "uncertainty") {
         if (_val.is_object()) {
            const auto type = _val.value("type", "");
            if (type == "symmetric")
               _data.err = to_number(_val.at("value"));
            else if (type == "range") {
               if (_val.contains("upperLimit") && _val.contains("lowerLimit")) {
                  const double upper = to_number(_val.at("upperLimit"));
                  const double lower = to_number(_val.at("lowerLimit"));
                  if (!value_set) _data.value = 0.5 * (upper + lower);
                  _data.err = 0.0;
                  _data.err_low = _data.value - lower;
                  _data.err_high = upper - _data.value;
               }
            }
         } else {
            _data.err = to_number(_val);
         }
      } else if (_key == "value") {
         _data.value = to_number(_val);
         value_set = true;
      } else if (_key == "unit")
         _data.unit = _val.get<tkstring>();
      else if (_key == "evaluatorInput")
         continue;
      else if (_key == "isSystematics" && (_val == "true" || (_val.is_boolean() && _val.get<bool>())))
         _data.info.append(";ERR=SY");
      else {
         glog << error << key << ": unkown key: " << _key << " type: " << _item.value().type_name() << do_endl;
         cout << _val << endl;
      }
   }
   if (_fromstd) {
      // extract value and err from nudat formated values
      if (entry.contains("formats") && entry.at("formats").contains("STD")) {
         tkstring format = entry.at("formats").at("STD").get<tkstring>();
         auto tokens = format.tokenize();
         _data.value = tokens.front().atof();
         if (tokens.size() == 2) {
            _data.err = tokens.back().atof();
         }
      }
   }
   _data.filled = true;
}
 
tkisotope_builder::json_nucleus tkisotope_builder::read_nucleus(json &entry)
{
   json_nucleus nuc;
   bool pause = false;
   for (auto &item : entry.items()) {
      auto &key = item.key();
      auto &val = item.value();
      if (key == "name")
         nuc.name = val;
      else if (key == "z")
         nuc.Z = val;
      else if (key == "n")
         nuc.N = val;
      else if (key == "a")
         nuc.A = val;
      else if (key == "bindingEnergy")
         continue;
      else if (key == "bindingEnergyLDMFit")
         continue;
      else if (key == "levels") {
         // pick the ground state level when isomers are present
         auto is_ground_state = [](const json &level) {
            if (!level.contains("energy")) return false;
            const auto &energy = level.at("energy");
            if (!energy.is_object() || !energy.contains("value")) return false;
            const auto &energy_val = energy.at("value");
            if (energy_val.is_string()) return energy_val.get<tkstring>().atof() == 0.0;
            if (energy_val.is_number()) return energy_val.get<double>() == 0.0;
            return false;
         };
         const json *level_ptr = nullptr;
         const auto it = std::find_if(val.begin(), val.end(), is_ground_state);
         bool picked_ground = (it != val.end());
         if (picked_ground)
            level_ptr = &(*it);
         else if (!val.empty())
            level_ptr = &val.front();
         if (!level_ptr) continue;
         for (auto &_item : level_ptr->items()) {
            const auto &_key = _item.key();
            const auto &_val = _item.value();
            if (_key == "decayModes") {
               if (_val.is_object() && (_val.contains("observed") || _val.contains("predicted"))) {
                  if (_val.contains("observed")) {
                     for (const auto &mode : _val.at("observed")) {
                        tkstring type = mode.value("mode", "");
                        tkstring ratio = "-1";
                        if (mode.contains("value")) {
                           if (mode.at("value").is_string())
                              ratio = mode.at("value").get<tkstring>();
                           else if (mode.at("value").is_number())
                              ratio = tkstring::form("%g", mode.at("value").get<double>());
                        }
                        nuc.decay_modes.emplace_back(type, ratio.atof());
                     }
                  }
                  if (_val.contains("predicted")) {
                     for (const auto &mode : _val.at("predicted")) {
                        tkstring type = mode.value("mode", "");
                        tkstring ratio = "-1";
                        nuc.decay_modes.emplace_back(type, ratio.atof());
                     }
                  }
               } else {
                  for (auto &mode : _val.items()) {
                     if (mode.value().size() == 3) {
                        tkstring type = mode.value().at("name");
                        tkstring symbol = mode.value().at("symbol");
                        tkstring ratio;
                        // unkown ratios
                        if (symbol == "?") {
                           symbol = "=";
                           ratio = "-1";
                        } else
                           ratio = mode.value().at("value");
                        nuc.decay_modes.emplace_back(type, ratio.atof());
                     } else {
                        tkstring type = mode.value().at("name");
                        type.remove_all("?");
                        tkstring symbol = "=";
                        tkstring ratio = "-1";
                        nuc.decay_modes.emplace_back(type, ratio.atof());
                     }
                  }
               }
            } else if (_key == "energy") {
               if (_val.empty()) continue;
               if (_val.size() < 2) continue;
               double ener = 0.0;
               const auto &energy_val = _val.at("value");
               if (energy_val.is_string())
                  ener = energy_val.get<tkstring>().atof();
               else if (energy_val.is_number())
                  ener = energy_val.get<double>();
               if (ener != 0. && picked_ground) {
                  glog << error << nuc.name << ": level is not ground state ! " << _val << do_endl;
               }
            } else if (_key == "massExcess")
               continue; // mass_excess is sourced exclusively from the primary AME table
            else if (_key == "abundance") {
               read_measure(_key, _val, nuc.abundance, true);
               nuc.abundance.unit = "%";
            }
            // include in the ensdf parsing
            else if (_key == "halflife" || _key == "spinAndParity" || _key == "spinParity")
               continue;
            else {
               glog << error << "levels: unkown key: " << _key << " type: " << _item.value().type_name() << do_endl;
               cout << _val << endl;
            }
         }
      } else if (key == "pairingGap")
         continue;
      else if (key == "qValues")
         continue;
      else if (key == "separationEnergies")
         continue;
      else if (key == "webLinks")
         continue;
      else if (key == "BE4DBE2")
         continue;
      // Level energies are sourced from ENSDF. These NuDat summary fields,
      // including firstZeroPlusEnergy and secondTwoPlusEnergy added on
      // 2026-09-17, are schema-validated above but intentionally not imported.
      else if (key == "excitedStateEnergies")
         continue;
      else if (key == "fissionYields") {
         for (auto &_item : val.items()) {
            const auto &_key = _item.key();
            const auto &_val = _item.value();
            if (_key == "FY235U")
               read_measure(_key, _val, nuc.FY235U);
            else if (_key == "FY238U")
               read_measure(_key, _val, nuc.FY238U);
            else if (_key == "FY239Pu")
               read_measure(_key, _val, nuc.FY239Pu);
            else if (_key == "FY241Pu")
               read_measure(_key, _val, nuc.FY241Pu);
            else if (_key == "FY252Cf")
               read_measure(_key, _val, nuc.FY252Cf);
            else if (_key == "cFY235U")
               read_measure(_key, _val, nuc.cFY235U);
            else if (_key == "cFY238U")
               read_measure(_key, _val, nuc.cFY238U);
            else if (_key == "cFY239Pu")
               read_measure(_key, _val, nuc.cFY239Pu);
            else if (_key == "cFY241Pu")
               read_measure(_key, _val, nuc.cFY241Pu);
            else if (_key == "cFY252Cf")
               read_measure(_key, _val, nuc.cFY252Cf);
            else {
               glog << error << key << ": unkown key: " << _key << " type: " << _item.value().type_name() << do_endl;
               cout << _val << endl;
            }
         }
      } else if (key == "quadrupoleDeformation")
         read_measure(key, val, nuc.quadrupoleDeformation);
      else if (key == "thermalNeutronCapture")
         continue;
      else if (key == "thermalNeutronFission")
         continue;
      else if (key == "discovery") {
         if (!val.is_object() || !val.contains("year")) continue;
         const auto &year = val.at("year");
         if (year.is_string())
            nuc.year = year.get<tkstring>().atoi();
         else if (year.is_number_integer())
            nuc.year = year.get<int>();
      }
      else {
         glog << warning << "unknown key: " << key << do_endl;
         cout << "value: " << endl;
         cout << val << endl;
         pause = true;
      }
   }
   if (pause) {
      nuc.print();
      cin.get();
   }
   return nuc;
}
 
#ifdef HAS_ROOT
ClassImp(tkisotope_builder);
#endif