condensed.hpp

Go to the documentation of this file.

#ifndef INDIGOX_GRAPH_CONDENSED_HPP
#define INDIGOX_GRAPH_CONDENSED_HPP

#include "../utils/fwd_declares.hpp"
#include "base_graph.hpp"

#include <EASTL/bitset.h>
#include <EASTL/vector_map.h>
#include <EASTL/vector_set.h>
#include <memory>
#include <vector>

namespace indigox::graph {
  using VertexIsoMask = eastl::bitset<37, uint64_t>;
  using EdgeIsoMask = eastl::bitset<14, uint16_t>;

  class CMGVertex {
  public:
    enum class ContractedSymmetry {
      Hydrogen, 
      Fluorine, 
      Chlorine, 
      Bromine,  
      Iodine    
    };

  private:
    friend class CondensedMolecularGraph;
    friend class cereal::access;
    using CondensedVertex = std::pair<ContractedSymmetry, MGVertex>;

    struct CMGVertexData;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(CMGVertex);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(CMGVertex, v);

  private:
    CMGVertex(const MGVertex &v, const CondensedMolecularGraph &g);

    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

  public:
    const MGVertex &GetSource() const;

    const CondensedMolecularGraph &GetGraph() const;

    size_t NumContracted() const;

    size_t NumContracted(ContractedSymmetry sym) const;

    const VertexIsoMask &GetIsomorphismMask() const;

    bool IsContractedHere(const MGVertex &v) const;

    std::vector<MGVertex> GetContractedVertices() const;
    const std::vector<CondensedVertex> &GetCondensedVertices() const;

  private:
    std::shared_ptr<CMGVertexData> m_data;
  };
  using ContractedSymmetry = CMGVertex::ContractedSymmetry;

  class CMGEdge {
    friend class CondensedMolecularGraph;
    friend class cereal::access;

    struct CMGEdgeData;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(CMGEdge);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(CMGEdge, e);

  private:
    CMGEdge(const MGEdge &e, const CondensedMolecularGraph &g);

    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

  public:
    const MGEdge &GetSource() const;

    const CondensedMolecularGraph &GetGraph() const;

    const EdgeIsoMask &GetIsomorphismMask() const;

  private:
    std::shared_ptr<CMGEdgeData> m_data;
  };

  class CondensedMolecularGraph
      : public BaseGraph<CMGVertex, CMGEdge, CondensedMolecularGraph> {
  public:
    friend class cereal::access;
    friend CondensedMolecularGraph Condense(const MolecularGraph &);
    friend class MolecularGraph;

    using graph_type = BaseGraph<CMGVertex, CMGEdge, CondensedMolecularGraph>;
    using VertContain = std::vector<CMGVertex>;
    using EdgeContain = std::vector<CMGEdge>;
    using NbrsContain = std::map<CMGVertex, VertContain>;
    using VertMap = eastl::vector_map<MGVertex, CMGVertex>;
    using EdgeMap = eastl::vector_map<MGEdge, CMGEdge>;

  public:
    using EdgeIter = EdgeContain::const_iterator;
    using VertIter = VertContain::const_iterator;
    using NbrsIter = NbrsContain::mapped_type::const_iterator;
    using VertexType = CMGVertex;
    using EdgeType = CMGEdge;

  private:
    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

    // Modification methods are private so that the CMG is a snapshot of the MG
    // at time of creation
    CMGEdge AddEdge(const MGEdge &e);

    CMGVertex AddVertex(const MGVertex &v);

    //    void Clear();

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(CondensedMolecularGraph);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(CondensedMolecularGraph, G);

  private:
    CondensedMolecularGraph(const MolecularGraph &g);

  public:
    CondensedMolecularGraph Subgraph(std::vector<CMGVertex> &verts);

    CondensedMolecularGraph Subgraph(std::vector<CMGVertex> &verts,
                                     std::vector<CMGEdge> &edges);

    bool IsSubgraph() const;
    //     {
    //      return bool(_subg);
    //    }

    const MolecularGraph &GetMolecularGraph() const;

    const CondensedMolecularGraph &GetSuperGraph() const;

    using graph_type::GetEdge;
    using graph_type::HasEdge;
    using graph_type::HasVertex;

    const CMGEdge &GetEdge(const MGEdge &e) const;

    const CMGVertex &GetVertex(const MGVertex &v) const;
    const CMGVertex &GetCondensedVertex(const MGVertex &v) const;

    bool HasVertex(const MGVertex &v) const;

    bool HasCondensedVertex(const MGVertex &v) const;

    bool HasEdge(const MGEdge &e) const;

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };

  CondensedMolecularGraph Condense(const MolecularGraph &G);

} // namespace indigox::graph

#endif /* INDIGOX_GRAPH_CONDENSED_HPP */