AbstractBoundingSphericalShell.h

Go to the documentation of this file.

#ifndef PMPL_ABSTRACT_BOUNDING_SPHERICAL_SHELL_H_
#define PMPL_ABSTRACT_BOUNDING_SPHERICAL_SHELL_H_
 
#include "Boundary.h"
#include "Geometry/Shapes/NSphericalShell.h"
 
 
class AbstractBoundingSphericalShell : public Boundary, public NSphericalShell {
 
  public:
 
 
    explicit AbstractBoundingSphericalShell(const size_t _n,
        const double _outer = std::numeric_limits<double>::max(),
        const double _inner = 0);
 
    explicit AbstractBoundingSphericalShell(const std::vector<double>& _center,
        const double _outer = std::numeric_limits<double>::max(),
        const double _inner = 0);
 
    AbstractBoundingSphericalShell(XMLNode& _node);
 
    virtual ~AbstractBoundingSphericalShell() noexcept;
 
 
    virtual size_t GetDimension() const noexcept override;
 
    virtual double GetMaxDist(const double _r1 = 2.0, const double _r2 = 0.5)
        const override;
 
    virtual const Range<double>& GetRange(const size_t _i) const override;
 
    virtual const std::vector<double>& GetCenter() const noexcept override;
 
    virtual double GetVolume() const noexcept override;
 
 
    virtual std::vector<double> GetRandomPoint() const override;
 
    virtual void PushInside(std::vector<double>& _sample) const noexcept override;
 
 
    using Boundary::InBoundary;
 
    virtual bool InBoundary(const std::vector<double>& _p) const override;
 
 
    virtual double GetClearance(const Vector3d& _p) const override;
 
    virtual Vector3d GetClearancePoint(const Vector3d& _p) const override;
 
 
    virtual void SetCenter(const std::vector<double>& _c) noexcept override;
 
    virtual void Translate(const Vector3d& _v) override;
 
    virtual void Translate(const std::vector<double>& _t) override;
 
    virtual void ResetBoundary(const std::vector<std::pair<double, double>>& _bbx,
        const double _margin) override;
 
 
    virtual void Read(std::istream& _is, CountingStreamBuffer& _cbs) override;
 
    virtual void Write(std::ostream& _os) const override;
 
 
  private:
 
 
    std::vector<Range<double>> ComputeRange() const;
 
 
    std::vector<Range<double>> m_range;
 
 
};
 
/*----------------------------------- I/O ------------------------------------*/
 
std::ostream& operator<<(std::ostream& _os,
    const AbstractBoundingSphericalShell& _b);
 
//std::istream& operator>>(std::istream& _is, const Boundary& _b);
 
/*----------------------------------------------------------------------------*/
 
#endif