element.h

Go to the documentation of this file.

//
// Project NuriKit - Copyright 2023 SNU Compbio Lab.
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef NURI_CORE_ELEMENT_H_
#define NURI_CORE_ELEMENT_H_

#include <algorithm>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
#include <absl/container/flat_hash_map.h>
 
#include "nuri/utils.h"
 
namespace nuri {
namespace internal {
  // Value taken from https://physics.nist.gov/cgi-bin/cuu/Value?are
  constexpr double kElectronMass = 5.48579909065e-4;
}  // namespace internal
 
struct Isotope {
  int atomic_number;
  int mass_number;
  double atomic_weight;
  double abundance;
};
 
constexpr bool operator==(const Isotope &lhs, const Isotope &rhs) noexcept {
  return &lhs == &rhs;
}
 
constexpr bool operator!=(const Isotope &lhs, const Isotope &rhs) noexcept {
  return &lhs != &rhs;
}

class Element {
public:
  enum class Type : std::uint8_t {
    kUnknown,
    kMetal,
    kMetalloid,
    kNonmetal,
  };
 
  enum class State : std::uint8_t {
    kUnknown,
    kSolid,
    kLiquid,
    kGas,
  };
 
  Element() = delete;
  ~Element() noexcept = default;

  constexpr int atomic_number() const noexcept { return atomic_number_; }

  constexpr std::int16_t valence_electrons() const noexcept {
    return valence_electrons_;
  }

  constexpr std::int16_t period() const noexcept { return period_; }

  constexpr std::int16_t group() const noexcept { return group_; }

  constexpr bool radioactive() const noexcept {
    return internal::check_flag(flags_, ElementFlags::kRadioactive);
  }

  constexpr bool main_group() const noexcept {
    return internal::check_flag(flags_, ElementFlags::kMainGroup);
  }

  constexpr bool lanthanide() const noexcept {
    return internal::check_flag(flags_, ElementFlags::kLanthanide);
  }

  constexpr bool actinide() const noexcept {
    return internal::check_flag(flags_, ElementFlags::kActinide);
  }

  constexpr Type type() const noexcept { return type_; }

  constexpr State state() const noexcept { return state_; }

  constexpr std::string_view symbol() const noexcept { return symbol_; }

  constexpr std::string_view name() const noexcept { return name_; }

  constexpr double atomic_weight() const noexcept { return atomic_weight_; }

  constexpr double covalent_radius() const noexcept { return cov_rad_; }

  constexpr double vdw_radius() const noexcept { return vdw_rad_; }

  constexpr double eneg() const noexcept { return eneg_; }

  constexpr const Isotope &major_isotope() const noexcept {
    return *major_isotope_;
  }

  const Isotope *find_isotope(int mass_number) const noexcept {
    auto it = std::find_if(isotopes_.begin(), isotopes_.end(),
                           [mass_number](const Isotope &iso) {
                             return iso.mass_number == mass_number;
                           });
    if (it == isotopes_.end()) {
      return nullptr;
    }
    return &(*it);
  }

  constexpr const std::vector<Isotope> &isotopes() const noexcept {
    return isotopes_;
  }
 
private:
  enum class ElementFlags : std::uint16_t {
    kRadioactive = 0x1,
    kMainGroup = 0x2,
    kLanthanide = 0x4,
    kActinide = 0x8,
  };
 
  Element(int atomic_number, std::string_view symbol, std::string_view name,
          double atomic_weight, double cov_rad, double vdw_rad, double eneg,
          std::vector<Isotope> &&isotopes) noexcept;
 
  Element(const Element &) = default;
  Element(Element &&) noexcept = default;
  Element &operator=(const Element &) = default;
  Element &operator=(Element &&) = default;
 
  friend class PeriodicTable;
 
  int atomic_number_;
  std::int16_t valence_electrons_;
  std::int16_t period_;
  std::int16_t group_;
  ElementFlags flags_;
  Type type_;
  State state_;
  std::string_view symbol_;
  std::string_view name_;
  double atomic_weight_;
  double cov_rad_;
  double vdw_rad_;
  double eneg_;
  const Isotope *major_isotope_;
  std::vector<Isotope> isotopes_;
};
 
constexpr bool operator==(const Element &lhs, const Element &rhs) noexcept {
  return lhs.atomic_number() == rhs.atomic_number();
}
 
constexpr bool operator!=(const Element &lhs, const Element &rhs) noexcept {
  return lhs.atomic_number() != rhs.atomic_number();
}

class PeriodicTable final {
public:
  PeriodicTable(const PeriodicTable &) = delete;
  PeriodicTable(PeriodicTable &&) noexcept = delete;
  PeriodicTable &operator=(const PeriodicTable &) = delete;
  PeriodicTable &operator=(PeriodicTable &&) noexcept = delete;
 
  ~PeriodicTable() noexcept = default;

  static const PeriodicTable &get() noexcept;

  constexpr const Element &operator[](int atomic_number) const noexcept {
    return elements_[atomic_number];
  }

  constexpr const Element *find_element(int atomic_number) const noexcept {
    return has_element(atomic_number) ? &elements_[atomic_number] : nullptr;
  }

  const Element *find_element(std::string_view symbol) const noexcept;

  const Element *find_element_of_name(std::string_view name) const noexcept;

  constexpr static bool has_element(int atomic_number) noexcept {
    return static_cast<unsigned int>(atomic_number)
           < static_cast<unsigned int>(kElementCount_);
  }

  bool has_element(std::string_view symbol) const noexcept;

  bool has_element_of_name(std::string_view name) const noexcept;
 
  const Element *begin() const noexcept { return elements_; }
  const Element *end() const noexcept { return elements_ + kElementCount_; }
 
  // 118 elements + dummy
  // NOLINTNEXTLINE(readability-identifier-naming)
  constexpr static int kElementCount_ = 118 + 1;
 
private:
  PeriodicTable() noexcept;
 
  Element elements_[kElementCount_];
  std::string symb_name_buf_;
  absl::flat_hash_map<std::string_view, const Element *> symbol_to_element_;
  absl::flat_hash_map<std::string_view, const Element *> name_to_element_;
};
 
// NOLINTNEXTLINE(readability-identifier-naming)
static const PeriodicTable &kPt = PeriodicTable::get();
}  // namespace nuri
 
#endif /* NURI_CORE_ELEMENT_H_ */