AtomEnvironmentHash.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_ATOM_ENVIRONMENT_HASH_H
#define INCLUDE_MOLASSEMBLER_ATOM_ENVIRONMENT_HASH_H

#include "boost/multiprecision/cpp_int.hpp"
#include "boost/optional.hpp"
#include "Utils/Geometry/ElementTypes.h"

#include "Molassembler/Shapes/Shapes.h"

#include "Molassembler/Types.h"

#include <vector>

namespace Scine {
namespace Molassembler {

// Forward-declarations
class StereopermutatorList;
class PrivateGraph;

namespace Hashes {

using WideHashType = boost::multiprecision::uint128_t;
using HashType = std::uint64_t;

struct BondInformation {
  static constexpr unsigned bondTypeBits = 3;
  static constexpr unsigned assignmentBits = 3;
  /* - 3 bits for bondtype + none
   * - 3 bits for the assignment (none, unassigned, values)
   */
  static constexpr unsigned hashWidth = 6;

  BondType bondType;
  bool stereopermutatorOnBond;
  boost::optional<unsigned> assignmentOptional;

  BondInformation(
    BondType passBondType,
    bool passStereopermutatorOnBond,
    boost::optional<unsigned> passAssignmentOptional
  );

  WideHashType hash() const;

  bool operator < (const BondInformation& other) const;
  bool operator == (const BondInformation& other) const;
};

WideHashType hash(
  AtomEnvironmentComponents bitmask,
  Utils::ElementType elementType,
  const std::vector<BondInformation>& sortedBonds,
  const boost::optional<Shapes::Shape>& shapeOptional,
  const boost::optional<unsigned>& assignedOptional
);

std::vector<BondInformation> gatherBonds(
  const PrivateGraph& inner,
  const StereopermutatorList& stereopermutators,
  AtomEnvironmentComponents componentsBitmask,
  AtomIndex i
);

WideHashType atomEnvironment(
  const PrivateGraph& inner,
  boost::optional<const StereopermutatorList&> stereopermutators,
  AtomEnvironmentComponents bitmask,
  AtomIndex i
);

std::vector<WideHashType> generate(
  const PrivateGraph& inner,
  boost::optional<const StereopermutatorList&> stereopermutatorsOption,
  AtomEnvironmentComponents bitmask
);

bool identityCompare(
  const PrivateGraph& aGraph,
  const StereopermutatorList& aStereopermutators,
  const PrivateGraph& bGraph,
  const StereopermutatorList& bStereopermutators,
  AtomEnvironmentComponents componentBitmask
);

std::tuple<
  std::vector<HashType>,
  std::vector<HashType>,
  HashType
> narrow(
  const std::vector<WideHashType>& a,
  const std::vector<WideHashType>& b
);

std::pair<
  std::vector<HashType>,
  std::vector<HashType>
> generate(
  const PrivateGraph& aGraph,
  const StereopermutatorList& aStereopermutators,
  const PrivateGraph& bGraph,
  const StereopermutatorList& bStereopermutators,
  AtomEnvironmentComponents bitmask
);

struct LookupFunctor {
  const std::vector<HashType>* const hashesPtr;

  using argument_type = AtomIndex;
  using result_type = HashType;

  inline LookupFunctor(const std::vector<HashType>& hashes) : hashesPtr(&hashes) {}

  inline HashType operator() (const AtomIndex i) const {
    return hashesPtr->at(i);
  }
};

} // namespace Hashes
} // namespace Molassembler
} // namespace Scine

#endif