regions.h

#pragma once
#include "core.h"
#include "molecule.h"
#include "group.h"
#include "space.h"

namespace Faunus {
class Space;

namespace Region {

enum class RegionType
{
    WITHIN_MOLID,
    WITHIN_PARTICLE,
    WITHIN_ELLIPSOID,
    INVALID
};

NLOHMANN_JSON_SERIALIZE_ENUM(RegionType, {{RegionType::INVALID, nullptr},
                                          {RegionType::WITHIN_MOLID, "within_molid"},
                                          {RegionType::WITHIN_PARTICLE, "around_particle"},
                                          {RegionType::WITHIN_ELLIPSOID, "ellipsoid"}})

class RegionBase
{
  private:
    [[nodiscard]] virtual bool
    isInside(const Point& position) const = 0; 
  public:
    const RegionType type;
    bool use_group_mass_center = false; 
    [[nodiscard]] virtual std::optional<double> volume() const; 
    virtual void to_json(json& j) const = 0;
    virtual ~RegionBase() = default;
    explicit RegionBase(RegionType type);

    [[nodiscard]] bool
    inside(const Particle& particle) const; 
    [[nodiscard]] bool inside(const Group& group) const; 

    template <typename ParticleRange> auto filterInside(const ParticleRange& particles) const
    {
        namespace rv = std::views;
        return particles | rv::transform(&Particle::pos) | rv::filter(&RegionBase::isInside);
    }
};

std::unique_ptr<RegionBase> createRegion(const Space& spc, const json& j);

void to_json(json& j, const RegionBase& region);

class WithinMoleculeType : public RegionBase
{
  private:
    const Space& spc;                     
    const MoleculeData::index_type molid; 
    const bool use_region_mass_center;    
    const double threshold_squared; 

    [[nodiscard]] inline bool within_threshold(const Point& position1, const Point& position2) const
    {
        return spc.geometry.sqdist(position1, position2) < threshold_squared;
    }

  public:
    WithinMoleculeType(const Space& spc, std::string_view molecule_name, double threshold,
                       bool use_region_mass_center, bool use_group_mass_center);
    WithinMoleculeType(const Space& spc, const json& j);
    [[nodiscard]] bool isInside(const Point& position) const override;
    [[nodiscard]] std::optional<double> volume() const override;
    void to_json(json& j) const override;
};

class SphereAroundParticle : public RegionBase
{
  private:
    const Space& spc; 
    const ParticleVector::size_type
        particle_index;          
    const double radius_squared; 

  public:
    SphereAroundParticle(const Space& spc, ParticleVector::size_type index, double radius);
    SphereAroundParticle(const Space& spc, const json& j);
    [[nodiscard]] bool isInside(const Point& position) const override;
    [[nodiscard]] std::optional<double> volume() const override;
    void to_json(json& j) const override;
};

class MovingEllipsoid : public RegionBase
{
  private:
    const Space& spc;
    const ParticleVector::size_type particle_index_1; 
    const ParticleVector::size_type particle_index_2; 
    const double parallel_radius;      
    const double perpendicular_radius; 
    const double parallel_radius_squared;

    const Point& reference_position_1; 
    const Point& reference_position_2; 

    [[nodiscard]] std::pair<Point, Point> getEllipsoidPositionAndDirection() const;

  public:
    MovingEllipsoid(const Space& spc, ParticleVector::size_type particle_index1,
                    ParticleVector::size_type particle_index2, double parallel_radius,
                    double perpendicular_radius, bool use_group_mass_center);
    MovingEllipsoid(const Space& spc, const json& j);
    [[nodiscard]] bool isInside(const Point& position) const override;
    void to_json(json& j) const override;
};

} // namespace Region
} // namespace Faunus