tkensdf_reader.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 <dirent.h>
 
#include "tkensdf_reader.h"
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
using namespace std;
 
bool tkensdf_reader::open_nuc(const tkstring &_nuc_name, const ensdf_data_type &_ftype)
{
   glog.set_class("ensdf_ascii_reader");
   glog.set_method(tkstring::form("open_nuc(%s,%d)", _nuc_name.data(), _ftype));
 
   if (TKN_SYS == nullptr) {
      glog << error_v << " TKN_SYS environment variable not defined, cannot find the repository of the data bases !" << do_endl;
      glog.clear();
      return false;
   }
 
   tkstring testnuc = _nuc_name.copy().to_lower();
   testnuc.capitalize();
 
   tkstring file_name;
   if (_ftype == kensdf)
      file_name = tkstring::Form("%s/ENSDF/%s.ens", finput_folder.data(), _nuc_name.data());
   else if (_ftype == kxundl)
      file_name = tkstring::Form("%s/XUNDL/%s.ens", finput_folder.data(), _nuc_name.data());
   else {
      glog << warning_v << " database for nucleus " << _nuc_name << " not found" << do_endl;
      glog.clear();
      return false;
   }
 
   fdata_type = _ftype;
   fNucleus = testnuc;
   glog.clear();
 
   return open_file(file_name);
}
 
bool tkensdf_reader::open_file(const tkstring &_file_name)
{
   glog.set_class("ensdf_ascii_reader");
   glog.set_method(tkstring::form("open_file(%s)", _file_name.data()));
 
   if (fEnsdf_file.is_open()) {
      close_file();
   }
   fEnsdf_file.open(_file_name);
 
   tkstring record;
   tkensdf_record the_record;
   tkensdf_ident_rec the_identification_record;
 
   // counters
   int read_record = 0;
 
   // true if a new data set is found
   bool new_dataset = false;
 
   // read the file and create the list of data sets.
   while (true) {
      getline(fEnsdf_file, record);
 
      if (!fEnsdf_file.good()) break;
 
      if (!the_record.set_record(record)) {
         glog << error_v << "error in : " << record << do_endl;
         continue;
      }
 
      if (!the_record.is_continuation_record()) frecords_counter[the_record.get_record_type()].first++;
      frecords_counter[the_record.get_record_type()].second++;
 
      // end of file
      if (!fEnsdf_file && new_dataset) {
         the_identification_record.fposition.second = read_record;
         fDataSets.push_back(the_identification_record);
         the_identification_record.clear();
         break;
      }
 
      read_record++;
 
      if (the_record.get_record_type() == tkensdf_record::kident && !new_dataset) {
         the_identification_record.set_record(record);
         the_identification_record.set_current_position(read_record);
         the_identification_record.set_start_position(read_record);
 
         if (fVerbose) the_identification_record.print(std::cout);
         new_dataset = true;
      }
      if (the_record.get_record_type() == tkensdf_record::kend && new_dataset) {
         the_identification_record.set_stpop_position(read_record);
         fDataSets.push_back(the_identification_record);
         the_identification_record.clear();
         new_dataset = false;
      }
   } // is_open
   if (fVerbose) glog << info << fDataSets.size() << " datasets have been found in the ENSDF file " << _file_name << do_endl;
 
   glog.clear();
 
   return fEnsdf_file.is_open();
}
 
void tkensdf_reader::print_datasets()
{
   if (!fEnsdf_file.is_open()) {
      glog << error << "No ENSDF database opened" << do_endl;
      return;
   }
   tkstring data_type = "ENSDF";
   if (fdata_type == kxundl) data_type = "XUNDL";
   glog << info << "Database type: " << data_type << do_endl;
   glog << info << fDataSets.size() << " datasets have been found for nucleus " << fNucleus << ":" << do_endl;
   for (auto &key : fDataSets) key.print(std::cout);
}
 
bool tkensdf_reader::first_record(tkensdf_ident_rec *_dataset, tkstring &record)
{
   // to remove any error flag
   fEnsdf_file.clear();
 
   if (_dataset == nullptr) return false;
   _dataset->set_current_position(_dataset->get_start_position());
   fEnsdf_file.seekg(_dataset->get_current_position() * tkensdf_record::RSIZE, std::ios::beg);
   getline(fEnsdf_file, record);
   return fEnsdf_file.good();
}
 
bool tkensdf_reader::next_record(tkensdf_ident_rec *_dataset, tkstring &record)
{
   if (_dataset == nullptr) return false;
   _dataset->set_current_position(_dataset->get_current_position() + 1);
   if (_dataset->get_current_position() >= _dataset->get_stop_position()) return false;
   getline(fEnsdf_file, record);
   return fEnsdf_file.good();
}
 
void tkensdf_reader::close_file()
{
   fDataSets.clear();
   fEnsdf_file.close();
   fEnsdf_file.clear();
   fNucleus.clear();
}
 
void tkensdf_reader::print_record_counters()
{
   std::cout << std::endl;
   glog << info << "Record counters:" << do_endl;
 
   size_t maxsize1 = 0;
   size_t maxsize2 = 0;
   for (auto i : frecords_counter) {
      if (tkstring::Form("%lld", i.second.first).length() > maxsize1) maxsize1 = tkstring::Form("%lld", i.second.first).length();
      if (tkstring::Form("%lld", i.second.second).length() > maxsize2) maxsize2 = tkstring::Form("%lld", i.second.second).length();
   }
   std::cout << left << " - Record Type     :  counts without(with) continuation records" << std::endl;
   for (auto i : frecords_counter) {
      if (i.first == tkensdf_record::kident)
         std::cout << left << " - identification  : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::khistory)
         std::cout << left << " - History         : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kq_value)
         std::cout << left << " - Q-value         : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kxref)
         std::cout << left << " - X-ref           : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kcomment)
         std::cout << left << " - Comment         : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kparent)
         std::cout << left << " - Parent          : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::knorm)
         std::cout << left << " - Normalisation   : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kprodnorm)
         std::cout << left << " - Production norm : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::klevel)
         std::cout << left << " - Level           : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kbeta)
         std::cout << left << " - Beta            : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kec)
         std::cout << left << " - EC              : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kalpha)
         std::cout << left << " - Alpha           : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kparticle)
         std::cout << left << " - Particle        : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kgamma)
         std::cout << left << " - Gamma           : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kreference)
         std::cout << left << " - Reference       : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kend)
         std::cout << left << " - End             : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
      else if (i.first == tkensdf_record::kunknown)
         std::cout << left << " - Unknown         : " << setw(maxsize1 + 1) << i.second.first << " (" << setw(maxsize2) << i.second.second << ")" << std::endl;
   }
   std::cout << std::endl;
}