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]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#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
 
    char * sErrMsg = nullptr;
 
    fTable.add_column("element_id","INT 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
    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);
        tkstring element_symbol = get<2>(elt.second.at("symbol"));
        if(element_symbol == "n") element_symbol = "neutron";
 
        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(tkstring::form("CREATE VIEW elt%s as select * from element where element.charge=%d",element_symbol.data(),current_charge));
        }
    }
 
    sqlite3_exec(fDataBase->get_sql_db(), "END TRANSACTION", nullptr, nullptr, &sErrMsg);
    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") {
            for(auto &col: entry.value().at("Column").items()) {
                units.push_back(col.value());
            }
        }
        else if(entry.key()=="Columns_Types") {
            for(auto &col: entry.value().at("Column").items()) {
                types.push_back(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 name = entry.value().at("name");
        auto xrays = entry.value().at("Xrays");
 
        vector<atomic_xray> atom_xrays;
        for(auto &xray: xrays) {
            tkstring name = xray.at("name").get<tkstring>();
            name.prepend("XRay_");
            tkstring unit = xray.at("unit").get<tkstring>();
            double value = xray.at("value").get<double>()/1000.;
            atom_xrays.emplace_back(name,unit,value);
            if(!fxrays_possible_names.count(name)) fxrays_possible_names.insert(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