PointGroupElements.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_SHAPES_POINT_GROUP_ELEMENTS_H
#define INCLUDE_MOLASSEMBLER_SHAPES_POINT_GROUP_ELEMENTS_H

#include "Molassembler/Shapes/PointGroups.h"

#include <Eigen/Core>
#include "boost/optional/optional_fwd.hpp"
#include "Molassembler/Temple/Preprocessor.h"

#include <vector>
#include <unordered_map>
#include <memory>

namespace Scine {
namespace Molassembler {
namespace Shapes {

namespace Elements {

struct MASM_EXPORT SymmetryElement {
  using Vector = Eigen::Vector3d;
  using Matrix = Eigen::Matrix3d;
  using Ptr = std::unique_ptr<SymmetryElement>;

  virtual ~SymmetryElement() = default;

  virtual Matrix matrix() const = 0;
  virtual boost::optional<Vector> vector() const = 0;
  virtual std::string name() const = 0;
};

struct MASM_EXPORT Identity final : public SymmetryElement {
  static Identity E();

  Matrix matrix() const final;
  boost::optional<Vector> vector() const final;
  std::string name() const final;
};

struct MASM_EXPORT Inversion final : public SymmetryElement {
  static Inversion i();

  Matrix matrix() const final;
  boost::optional<Vector> vector() const final;
  std::string name() const final;
};

struct MASM_EXPORT Rotation final : public SymmetryElement {
  Rotation(
    const Eigen::Vector3d& passAxis,
    unsigned passN,
    unsigned passPower,
    bool passReflect
  );

  static Rotation Cn(const Eigen::Vector3d& axis, unsigned n, unsigned power = 1);
  static inline Rotation Cn_z(const unsigned n, const unsigned power = 1) {
    return Cn(Eigen::Vector3d::UnitZ(), n, power);
  }
  static Rotation Sn(const Eigen::Vector3d& axis, unsigned n, unsigned power = 1);

  Rotation operator * (const Rotation& rhs) const;

  Matrix matrix() const final;
  boost::optional<Vector> vector() const final;
  std::string name() const final;

  Eigen::Vector3d axis;
  unsigned n;
  unsigned power;
  bool reflect;

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

struct MASM_EXPORT Reflection final : public SymmetryElement {
  Reflection(const Eigen::Vector3d& passNormal);

  static Reflection sigma_xy();
  static Reflection sigma_xz();
  static Reflection sigma_yz();

  Matrix matrix() const final;
  boost::optional<Vector> vector() const final;
  std::string name() const final;

  Eigen::Vector3d normal;

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

/* Mixed operators (WARNING: Can only handle case for which rotation axis is
 * collinear with reflection plane normal)
 */
MASM_EXPORT Rotation operator * (const Rotation& rot, const Reflection& reflection);
MASM_EXPORT Rotation operator * (const Reflection& reflection, const Rotation& rot);

using ElementsList = std::vector<std::unique_ptr<SymmetryElement>>;

PURITY_WEAK MASM_EXPORT ElementsList symmetryElements(PointGroup group) noexcept;

PURITY_STRONG MASM_EXPORT unsigned order(PointGroup group);

struct MASM_EXPORT ElementGrouping {
  using ElementIndexGroups = std::vector<std::vector<unsigned>>;

  Eigen::Vector3d probePoint;
  ElementIndexGroups groups;

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

using NpGroupingsMapType = std::unordered_map<
  unsigned,
  std::vector<ElementGrouping>,
  std::hash<unsigned>,
  std::equal_to<>,
  Eigen::aligned_allocator<std::pair<const unsigned, std::vector<ElementGrouping>>>
>;

MASM_EXPORT NpGroupingsMapType npGroupings(const ElementsList& elements);

} // namespace Elements
} // namespace Shapes
} // namespace Molassembler
} // namespace Scine

#endif