atomdata.h

#pragma once
#include "core.h"
#include "aux/json_support.h"
#include <algorithm>
#include <range/v3/range/conversion.hpp>

namespace Faunus {

class InteractionData
{
    using key_type = std::string;
    std::map<key_type, double> data; 
    friend void to_json(json&, const InteractionData&);

  public:
    bool contains(const key_type& name) const;                 // like C++20 map::contains
    double at(const key_type& name) const;                     // like map::at()
    double& at(const key_type& name);                          // like map::at()
    void insert_or_assign(const key_type& name, double value); // like C++17 map::insert_or_assign
};

void to_json(json& j, const InteractionData& a);
void from_json(const json& j, InteractionData& a);
void from_single_use_json(SingleUseJSON& j, InteractionData& a);

class SpheroCylinderData
{
  protected:
    friend void from_json(const json&, SpheroCylinderData&);
    friend void to_json(json&, const SpheroCylinderData&);

  public:
    enum class PatchType
    {
        None = 0,   
        Full = 1,   
        Capped = 2, 
        Invalid = 3 
    }; 
    double chiral_angle = 0.0; 
    double length = 0.0;       
    double patch_angle = 0.0;  
    double patch_angle_switch =
        0.0; 
    PatchType type = PatchType::None; 
};

void from_json(const json& j, SpheroCylinderData& psc);
void to_json(json& j, const SpheroCylinderData& psc);

NLOHMANN_JSON_SERIALIZE_ENUM(SpheroCylinderData::PatchType,
                             {{SpheroCylinderData::PatchType::Invalid, nullptr},
                              {SpheroCylinderData::PatchType::Full, "full"},
                              {SpheroCylinderData::PatchType::Capped, "capped"},
                              {SpheroCylinderData::PatchType::None, "none"}})

class AtomData
{ // has to be a class when a constant reference is used
  public:
    using index_type = std::size_t; 

  private:
    index_type _id = 0;
    friend void to_json(json&, const AtomData&);
    friend void from_json(const json&, AtomData&);

  public:
    std::string name;    
    double charge = 0;   
    double mw = 1;       
    double sigma = 0;    
    double activity = 0; 
    double alphax = 0;   
    std::optional<double> dp = std::nullopt;    
    std::optional<double> dprot = std::nullopt; 
    double tension = 0;                         
    double tfe = 0;                             
    Point mu = {0, 0, 0};                       
    double mulen = 0;                           
    bool hydrophobic = false;                   
    bool implicit = false;                      
    double scattering_f0 = 1.0;                 
    InteractionData
        interaction; 
    SpheroCylinderData sphero_cylinder; 

    index_type& id();             
    const index_type& id() const; 
};

void to_json(json& j, const AtomData& a);
void from_json(const json& j, AtomData& a);

void from_json(const json& j, std::vector<AtomData>& atom_vector);

extern std::vector<AtomData> atoms; 

template <typename T>
concept RequireNamedElements = requires(T db) {
    { db.begin() };
    { db.begin()->name } -> std::convertible_to<std::string>;
    { std::is_integral_v<typename std::ranges::range_value_t<T>::index_type> };
};

auto findName(RequireNamedElements auto& range, std::string_view name)
{
    return std::find_if(range.begin(), range.end(), [&](auto& i) { return i.name == name; });
}

auto findName(const RequireNamedElements auto& range, std::string_view name)
{
    return std::find_if(range.begin(), range.end(), [&](const auto& i) { return i.name == name; });
}

struct UnknownAtomError : public GenericError
{
    explicit UnknownAtomError(std::string_view atom_name);
};

AtomData& findAtomByName(std::string_view name);

template <RequireNamedElements T>
auto names2ids(const T& database, const std::vector<std::string>& names)
{
    namespace rv = std::views;

    auto is_wildcard = [](auto& name) { return name == "*"; };
    if (std::ranges::any_of(names, is_wildcard)) { // return all id's from database
        return database | rv::transform([](auto& i) { return i.id(); }) | ranges::to_vector;
    }

    auto name_to_id = [&](auto& name) {
        if (auto iter = findName(database, name); iter != database.end()) {
            return iter->id();
        }
        throw std::out_of_range("name '" + name + "' not found");
    };
    return names | rv::transform(name_to_id) | ranges::to_vector;
}

} // namespace Faunus