tkelement_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 "tkelement_builder.h"
 
#include <fstream>
 
#include "tklog.h"
#include "json.hpp"
 
namespace tkn {
}
 
using namespace tkn;
using namespace std;
using json = nlohmann::json;
 
tkelement_builder::tkelement_builder(tkdatabase *_database, const char *_table_name) : fDataBase(_database), fTableName(_table_name)
{
}
 
tkelement_builder::~tkelement_builder() = default;
 
int tkelement_builder::fill_database(const char *_atomic_db, const char* _xrays_db, int _only_charge)
{
    glog.set_class("db_element_builder");
    glog.set_method(tkstring::form("fill_database('%s')",_atomic_db));
 
    gdebug << "calling tkelement_builder::fill_database(...)" << do_endl;
 
    tkdb_table &fTable = fDataBase->new_table(fTableName);
    read_atomic_db(_atomic_db);
    read_xrays_db(_xrays_db);
 
    // table initialisation
 
    fTable.add_column("element_id","INTEGER PRIMARY KEY NOT NULL");
 
    for(auto &idx: indexes) {
        tkstring name = columns.at(idx);
        tkstring type = types.at(idx);
        fTable.add_column(name.data(),type.data());
        if(units.at(idx) != "None") {
            name += "_unit";
            fTable.add_column(name.data(),"TEXT");
        }
    }
    for(auto &xray: fxrays_possible_names) {
        fTable.add_column(xray.data(),"FLOAT");
    }
    fTable.write_to_database();
 
    // filling the database
    fDataBase->exec_sql("BEGIN TRANSACTION");
    int idx = 1;
    for(auto &elt: fmap_of_atomic_properties) {
        tkstring message = "Building '" + fTable.get_name() + "' table";
        glog.progress_bar(fmap_of_atomic_properties.size(),idx,message.data());
 
//        fTable["element_id"].set_value(idx++);
        int current_charge = get<2>(elt.second.at("charge")).atoi();
        fTable["element_id"].set_value(current_charge+1);
 
        for(auto &prop : elt.second) {
            tkstring name  = get<0>(prop.second);
            tkstring unit  = get<1>(prop.second);
            tkstring value = get<2>(prop.second);
            tkstring type  = get<3>(prop.second);
 
            if(type.contains("INT")) fTable[name.data()].set_value(value.atoi());
            else if(type.contains("TEXT")) fTable[name.data()].set_value(value.data());
            else if(type.contains("FLOAT")) fTable[name.data()].set_value(value.atof());
            if(unit !="None") fTable[tkstring::form("%s_unit",name.data())].set_value(unit.data());
        }
        if(fmap_of_xrays.count(current_charge)) {
            for(auto &xray: fmap_of_xrays.at(current_charge)) {
                tkstring name, unit; double value;
                std::tie(name, unit, value) = xray;
                fTable[name.data()].set_value(value);
            }
        }
        bool do_push = (_only_charge==0 || _only_charge==current_charge);
        if(do_push) {
            fTable.push_row();
        }
    }
 
    fDataBase->exec_sql("COMMIT");
    fDataBase->exec_sql("CREATE INDEX charge_index ON element(charge)");
 
    glog.clear();
 
    return 0;
}
 
void tkelement_builder::read_atomic_db(const char *_atomic_db) {
 
    gdebug << "filling atomic database using : " << _atomic_db << do_endl;
 
    std::ifstream f_in;
    f_in.open(_atomic_db);
    json jf = json::parse(f_in);
 
 
 
    auto &table = jf.at("Table");
 
    for(auto &entry: table.items()) {
        if(entry.key()=="Columns") {
            for(auto &col: entry.value().at("Column").items()) {
                columns.push_back(col.value());
                if(col.value()=="CPKHexColor") continue;
                if(col.value()=="electronegativity") continue;
                if(col.value()=="electron_affinity") continue;
                if(col.value()=="oxidation_states") continue;
 
                indexes.push_back(tkstring(col.key()).atoi());
            }
        }
        else if(entry.key()=="Columns_Units") {
            const auto &cols = entry.value().at("Column");
            auto cols_items = cols.items();
            units.reserve(units.size() + cols.size());
            std::transform(cols_items.begin(), cols_items.end(), std::back_inserter(units),
                           [](const auto &col) { return col.value(); });
        }
        else if(entry.key()=="Columns_Types") {
            const auto &cols = entry.value().at("Column");
            auto cols_items = cols.items();
            types.reserve(types.size() + cols.size());
            std::transform(cols_items.begin(), cols_items.end(), std::back_inserter(types),
                           [](const auto &col) { return col.value(); });
        }
        else if(entry.key()=="Row") {
            for(auto &elt: entry.value().items()) {
                auto col = elt.value().at("Cell");
                int atomic_number = col.at(0).get<tkstring>().atoi();
                map<tkstring,atomic_properties> properties;
                for(auto &i: indexes) {
                    if(col.at(i).get<tkstring>().length()==0) continue;
                    properties.insert({columns.at(i),{columns.at(i),units.at(i),col.at(i).get<tkstring>(),types.at(i)}});
                }
                fmap_of_atomic_properties.insert({atomic_number,properties});
            }
        }
    }
 
    //    for(auto &elt: fmap_of_atomic_properties) {
    //        glog << info <<"New element: " << get<2>(elt.second.at("name")) << do_endl;
    //        for(auto &prop : elt.second) {
    //            cout << left << setw(40) << prop.first << " = " << get<2>(prop.second);
    //            if(get<1>(prop.second) != "None") cout << " " << get<1>(prop.second);
    //            cout<<endl;
    //        }
    //    }
}
 
void tkelement_builder::read_xrays_db(const char *_xrays_db) {
 
    std::ifstream f_in;
    f_in.open(_xrays_db);
 
    json jf = json::parse(f_in);
 
    auto &table = jf.at("Elements");
 
    for(auto &entry: table.items()) {
        auto Z = entry.value().at("Z");
        auto element_name = entry.value().at("name");
        auto xrays = entry.value().at("Xrays");
 
        vector<atomic_xray> atom_xrays;
        for(auto &xray: xrays) {
            tkstring xray_name = xray.at("name").get<tkstring>();
            xray_name.prepend("XRay_");
            tkstring unit = xray.at("unit").get<tkstring>();
            double value = xray.at("value").get<double>()/1000.;
            atom_xrays.emplace_back(xray_name,unit,value);
            if(!fxrays_possible_names.count(xray_name)) fxrays_possible_names.insert(xray_name);
        }
        if(!atom_xrays.empty()) fmap_of_xrays.insert({Z,atom_xrays});
    }
 
//    tkstring name, unit;
//    double value;
//    for(auto &elt: fmap_of_xrays) {
//        cout << elt.first << " " << endl;
//        for(auto &xray: elt.second) {
//            std::tie(name, unit, value) = xray;
//            cout << "   -- " << setw(10) << name << " : " << setw(10) << value << " " << unit << endl;
//        }
//    }
}
 
#ifdef HAS_ROOT
ClassImp(tkelement_builder);
#endif