ConfigData.hh

Go to the documentation of this file.

#ifndef CASM_DB_ConfigData
#define CASM_DB_ConfigData
 
#include "casm/casm_io/Log.hh"
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/casm_io/dataformatter/DataFormatterTools.hh"
#include "casm/clex/MappedProperties.hh"
#include "casm/global/definitions.hh"
 
// To be specialized for calculable 'ConfigType' classes:
//   Import<ConfigType>::desc
//   Import<ConfigType>::run
//   Import<ConfigType>::_import_formatter
//   Update<ConfigType>::desc
//   Update<ConfigType>::run
//   Update<ConfigType>::_update_formatter
//   Remove<ConfigType>::desc
//   Remove<ConfigType>::run
 
namespace CASM {
 
class PrimClex;
class Supercell;
 
namespace DB {
 
template <typename T>
class Selection;
template <typename ValueType>
class Database;
template <typename ValueType>
class DatabaseIterator;
class PropertiesDatabase;
 
std::string create_report_dir(std::string report_dir);
 
namespace ConfigIO {
 
struct ImportData {
  ImportData()
      : preexisting(false),
        copy_data(false),
        copy_more(false),
        is_best(false) {}
 
  // base responsibility:
  bool preexisting;
  bool copy_data;
  bool copy_more;
  bool is_best;
};
 
struct Result {
  Result() : has_data(false), has_complete_data(false), is_new_config(false) {}
 
  // Set 'to'/'from' as empty strings if no mapping possible
  MappedProperties properties;
 
  // Path to properties.calc.json or POS file that was imported
  std::string pos_path;
 
  // If a properties.calc.json file is found in standard locations
  bool has_data;
 
  // If all PrimClex required properties exist
  bool has_complete_data;
 
  // If 'to' Configuration did not exist in the database prior to mapping
  bool is_new_config;
 
  // If mapping failed, stores any error message that may be generated
  std::string fail_msg;
 
  ImportData import_data;
};
 
GenericDatumFormatter<std::string, Result> initial_path();
 
GenericDatumFormatter<std::string, Result> final_path();
 
GenericDatumFormatter<std::string, Result> fail_msg();
 
GenericDatumFormatter<std::string, Result> data_origin();
 
GenericDatumFormatter<std::string, Result> to_configname();
 
GenericDatumFormatter<bool, Result> has_data();
 
GenericDatumFormatter<bool, Result> has_complete_data();
 
GenericDatumFormatter<bool, Result> preexisting_data();
 
GenericDatumFormatter<bool, Result> import_data();
 
GenericDatumFormatter<bool, Result> import_additional_files();
 
GenericDatumFormatter<double, Result> lattice_deformation_cost();
 
GenericDatumFormatter<double, Result> atomic_deformation_cost();
 
GenericDatumFormatter<double, Result> energy();
 
GenericDatumFormatter<double, Result> score();
 
GenericDatumFormatter<double, Result> best_score();
 
GenericDatumFormatter<bool, Result> is_best();
 
GenericDatumFormatter<bool, Result> is_new_config();
 
GenericDatumFormatter<bool, Result> selected();
 
void default_import_formatters(DataFormatterDictionary<Result> &dict,
                               PropertiesDatabase &db_props);
 
void default_update_formatters(DataFormatterDictionary<Result> &dict,
                               PropertiesDatabase &db_props);
 
}  // namespace ConfigIO
 
template <typename T>
struct TypeTag {
  using type = T;
};
 
class ConfigData {
 public:
 
  // Otherwise return pos_path
  static std::string resolve_struc_path(std::string pos_path,
                                        PrimClex const &_pclex);
 
  template <typename ConfigType>
  ConfigData(const PrimClex &_primclex, TypeTag<ConfigType>);
 
  const PrimClex &primclex() const { return m_primclex; }
 
  Database<Supercell> &db_supercell() const;
 
  template <typename ConfigType>
  Database<ConfigType> &db_config() const;
 
  PropertiesDatabase &db_props() const;
 
  std::string calc_dir(const std::string configname) const;
 
  bool has_existing_files(const std::string &to_configname) const;
 
  bool has_existing_data(const std::string &to_configname) const;
 
  bool has_existing_data_or_files(const std::string &to_configname) const;
 
  bool no_change(const std::string &configname) const;
 
  void rm_files(const std::string &configname, bool dry_run) const;
 
  void cp_files(ConfigIO::Result &res, bool dry_run,
                bool copy_additional_files) const;
 
 private:
  const PrimClex &m_primclex;
  std::function<PropertiesDatabase &()> m_db_props_func;
};
 
// To be specialized for ConfigType (no default implemenation exists)
template <typename ConfigType>
class StructureMap;
 
/*
  template<typename ConfigType>
  class StructureMap {
 
public:
 
  typedef std::back_insert_iterator<std::vector<ConfigIO::Result> >
map_result_inserter;
 
exist or be valid.
unknown as with 'casm import'.
specied path
  map_result_inserter map(
    std::string p,
    DatabaseIterator<ConfigType> hint,
    map_result_inserter result) const;
};
*/
}  // namespace DB
}  // namespace CASM
 
#endif