Esempio n. 1
0
    def __init__(
        self,
        molecule1,
        molecule2,
        prematched=[],
        vertex_equality=None,
        edge_equality=None,
        maxsol=0,
    ):

        if vertex_equality is None:
            import operator
            vertex_equality = operator.eq

        if edge_equality is None:
            import operator
            edge_equality = operator.eq

        self.molecule1 = molecule1.atom_for
        self.molecule2 = molecule2.atom_for
        self.best = [[]]
        self.largest = 0

        from boost_adaptbx.graph import maximum_clique

        self.compat_graph = maximum_clique.compatibility_graph(
            first=molecule1.graph,
            second=molecule2.graph,
            vertex_equality=vertex_equality,
            edge_equality=edge_equality)

        self.prematched = prematched

        if self.prematched:
            desc_for_1 = molecule1.descriptor_for
            desc_for_2 = molecule2.descriptor_for
            pairs = set([(desc_for_1[l], desc_for_2[r])
                         for (l, r) in self.prematched])
            vertices = [
                v for v in self.compat_graph.vertices()
                if self.compat_graph.vertex_label(vertex=v) in pairs
            ]

            assert len(vertices) == len(self.prematched)
            neighbours = set(
                self.compat_graph.adjacent_vertices(vertex=vertices[0]))

            for v in vertices[1:]:
                neighbours.intersection_update(
                    self.compat_graph.adjacent_vertices(vertex=v))

            self.compat_graph = maximum_clique.selected_subgraph(
                graph=self.compat_graph,
                vertices=neighbours,
            )

        self.result = maximum_clique.greedy(graph=self.compat_graph,
                                            maxsol=maxsol)
Esempio n. 2
0
    def manipulation(self, g):

        n = {}
        n["1,1'"] = g.add_vertex(label="1,1'")  # 0
        n["1,5'"] = g.add_vertex(label="1,5'")  # 1
        n["2,2'"] = g.add_vertex(label="2,2'")  # 2
        n["2,3'"] = g.add_vertex(label="2,3'")  # 3
        n["3,2'"] = g.add_vertex(label="3,2'")  # 4
        n["3,3'"] = g.add_vertex(label="3,3'")  # 5
        n["4,4'"] = g.add_vertex(label="4,4'")  # 6
        n["5,1'"] = g.add_vertex(label="5,1'")  # 7
        n["5,5'"] = g.add_vertex(label="5,5'")  # 8

        g.add_edge(vertex1=n["1,1'"], vertex2=n["3,3'"])
        g.add_edge(vertex1=n["1,1'"], vertex2=n["4,4'"])
        g.add_edge(vertex1=n["1,1'"], vertex2=n["5,5'"])

        g.add_edge(vertex1=n["1,5'"], vertex2=n["3,2'"])
        g.add_edge(vertex1=n["1,5'"], vertex2=n["4,4'"])
        g.add_edge(vertex1=n["1,5'"], vertex2=n["5,1'"])

        g.add_edge(vertex1=n["2,2'"], vertex2=n["3,3'"])
        g.add_edge(vertex1=n["2,2'"], vertex2=n["4,4'"])
        g.add_edge(vertex1=n["2,2'"], vertex2=n["5,5'"])

        g.add_edge(vertex1=n["2,3'"], vertex2=n["3,2'"])
        g.add_edge(vertex1=n["2,3'"], vertex2=n["5,1'"])

        g.add_edge(vertex1=n["3,2'"], vertex2=n["5,1'"])

        g.add_edge(vertex1=n["3,3'"], vertex2=n["4,4'"])
        g.add_edge(vertex1=n["3,3'"], vertex2=n["5,5'"])

        g.add_edge(vertex1=n["4,4'"], vertex2=n["5,1'"])
        g.add_edge(vertex1=n["4,4'"], vertex2=n["5,5'"])

        subgraph = maximum_clique.selected_subgraph(
            graph=g, vertices=g.adjacent_vertices(vertex=n["2,2'"]))
        vertices = list(subgraph.vertices())
        self.assertEqual(len(vertices), 3)
        self.assertEqual(
            set(subgraph.vertex_label(vertex=v) for v in vertices),
            set(["3,3'", "4,4'", "5,5'"]))

        edges = list(subgraph.edges())
        self.assertEqual(len(edges), 3)
        self.assertEqual(
            set(
                frozenset([
                    subgraph.vertex_label(vertex=subgraph.source(edge=e)),
                    subgraph.vertex_label(vertex=subgraph.target(edge=e)),
                ]) for e in edges),
            set([
                frozenset(["3,3'", "4,4'"]),
                frozenset(["3,3'", "5,5'"]),
                frozenset(["4,4'", "5,5'"]),
            ]))
Esempio n. 3
0
    def subset(self, atoms):

        if not all(a in self.descriptor_for for a in atoms):
            raise ValueError, "Unknown atoms: %s" % atoms

        from boost_adaptbx.graph import maximum_clique
        subgraph = maximum_clique.selected_subgraph(
            graph=self.graph,
            vertices=(self.descriptor_for[a] for a in atoms),
        )

        return self.__class__(graph=subgraph)