tkmoments_builder.h

/********************************************************************************
 *   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                                               *
 ********************************************************************************/
 
#ifndef tkmoments_builder_H
#define tkmoments_builder_H
 
#include "tkdatabase.h"
 
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace tkn {

class tkmoments_builder {
public:
   explicit tkmoments_builder(tkdatabase *_database);
   virtual ~tkmoments_builder() = default;
 
   int fill_database(const char *_magnetic_filename,
                     const char *_quadrupole_filename,
                     int _only_charge = 0,
                     int _only_mass = 0);
   int fill_database(const char *_magnetic_filename,
                     const char *_quadrupole_filename,
                     int _only_charge,
                     int _only_mass,
                     const char *_corrections_filename);
 
   int get_imported_ground_state_count() const { return fImportedGroundStates; }
   int get_imported_level_count() const { return fImportedLevels; }
   int get_skipped_value_count() const { return fSkippedValues; }
   int get_unmatched_level_count() const { return fUnmatchedLevels; }
   int get_source_row_count() const { return fSourceRows; }
   int get_level_candidate_row_count() const { return fLevelCandidateRows; }
   int get_physically_forbidden_count() const { return fPhysicallyForbidden; }
   int get_relaxed_level_match_count() const { return fRelaxedLevelMatches; }
   int get_parity_relaxed_match_count() const { return fParityRelaxedMatches; }
   int get_repaired_spin_match_count() const { return fRepairedSpinMatches; }
   int get_corrected_source_field_count() const { return fCorrectedSourceFields; }
   int get_alternative_moment_row_count() const { return fAlternativeMomentRows; }
   int get_incompatible_alternative_moment_row_count() const
   { return fIncompatibleAlternativeMomentRows; }
 
private:
   struct level_candidate {
      int id = -1;
      double energy = 0.;
      std::string offset;
      std::string spin_parity;
      double lifetime = 0.;
      std::string lifetime_unit;
      bool has_lifetime = false;
      bool stable = false;
   };
 
   struct level_match {
      int id = -1;
      std::string method;
      std::string adopted_spin;
   };
 
   struct parsed_energy {
      double value = 0.;
      std::string offset;
      bool valid = false;
   };
 
   struct parsed_moment {
      double value = 0.;
      double uncertainty = 0.;
      double uncertainty_low = 0.;
      double uncertainty_high = 0.;
      bool asymmetric = false;
      bool has_uncertainty = false;
      std::string info;
      std::string source_fix;
      std::string alternative;
      bool alternative_incompatible = false;
      bool valid = false;
   };
 
   using nucleus_key = std::pair<int, int>;
 
   tkdatabase *fDataBase = nullptr;
   bool fHasLevelTable = false;
   std::map<nucleus_key, int> fIsotopeIds;
   std::map<nucleus_key, bool> fIsotopeStable;
   std::map<nucleus_key, std::vector<level_candidate>> fAdoptedLevels;
   std::map<int, std::string> fLevelSpins;
 
   int fImportedGroundStates = 0;
   int fImportedLevels = 0;
   int fSkippedValues = 0;
   int fUnmatchedLevels = 0;
   int fSourceRows = 0;
   int fLevelCandidateRows = 0;
   int fPhysicallyForbidden = 0;
   int fRelaxedLevelMatches = 0;
   int fParityRelaxedMatches = 0;
   int fRepairedSpinMatches = 0;
   int fCorrectedSourceFields = 0;
   int fAlternativeMomentRows = 0;
   int fIncompatibleAlternativeMomentRows = 0;
 
   bool load_targets();
   bool clear_existing_moments(int _only_charge, int _only_mass) const;
   int 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);
 
   static parsed_energy parse_energy(const std::string &_text);
   static parsed_moment parse_moment(const std::string &_text);
   static std::string normalize_spin(const std::string &_text);
   static bool spin_matches(const std::string &_stone_spin,
                            const std::string &_ensdf_spin);
   static bool static_moment_allowed(const std::string &_property_name,
                                     const std::string &_spin);
   static bool lifetime_matches(const std::string &_stone_lifetime,
                                const level_candidate &_candidate);
 
   level_match find_level(const nucleus_key &_nucleus,
                          const parsed_energy &_energy,
                          const std::string &_spin,
                          const std::string &_lifetime) const;
   bool 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;
};
 
} // namespace tkn
 
#endif