Beispiel #1
0
    def test_analyze_clustering(self):
        separated_decomposed_clusters = {
            'mixed': {
                '1': {
                    'traj_A': [3],
                    'traj_B': [8, 10]
                },
                '2': {
                    'traj_A': [4],
                    'traj_B': [14, 15]
                }
            },
            'pure': {
                '0': {
                    'traj_A': [0, 1, 2]
                },
                '3': {
                    'traj_A': [5, 6]
                },
                '4': {
                    'traj_B': [9, 11, 12, 13, 7]
                }
            }
        }

        expected_analysis = {
            'num_pure': 3,
            'num_mixed': 2,
            'num_mixed_elements': 6,
            'total_num_clusters': 5,
            'num_pure_elements': 10,
            'total_num_elements': 16,
            'overlap': 0.054930609464645341,
        }
        analysis = {}
        Analyzer.analyze_clustering(separated_decomposed_clusters, self.matrix,
                                    analysis)
        self.assertDictEqual(expected_analysis, analysis)
Beispiel #2
0
    def test_analyze_clustering(self):
        separated_decomposed_clusters = {
            'mixed': {
                      '1': {
                            'traj_A': [3],
                            'traj_B': [8, 10]
                            },
                      '2': {
                            'traj_A': [4],
                            'traj_B': [14, 15]
                            }
                      },
            'pure': {
                     '0': {
                           'traj_A': [0, 1, 2]
                           },
                     '3': {
                           'traj_A': [5, 6]
                           },
                     '4': {
                           'traj_B': [9, 11, 12, 13, 7]
                           }
                     }
        }

        expected_analysis = {
                             'num_pure': 3,
                             'num_mixed': 2,
                             'num_mixed_elements': 6,
                             'total_num_clusters': 5,
                             'num_pure_elements': 10,
                             'total_num_elements': 16,
                             'overlap': 0.054930609464645341,
                             }
        analysis = {}
        Analyzer.analyze_clustering(separated_decomposed_clusters, self.matrix, analysis)
        self.assertDictEqual(expected_analysis, analysis)
def conformational_space_comparison(clustering, trajectoryHandler,  matrixHandler, 
                         clustering_parameters, refinement_parameters):

#     clustering = Refiner(matrixHandler,
#                          trajectoryHandler,
#                          clustering_parameters,
#                          refinement_parameters,
#                          observer).run(clustering)

    traj_ranges = {}
    current = 0
    for i, pdb_source in enumerate(trajectoryHandler.sources):
        num_confs = pdb_source.get_info("number_of_conformations")
        traj_ranges["traj_%d"%i] = (current, current + num_confs -1)
        current = current + num_confs

    decomposed_clusters = Separator.separate(clustering.clusters, traj_ranges)

    analysis = Analyzer.run(decomposed_clusters, matrixHandler.distance_matrix)

    return analysis
Beispiel #4
0
def conformational_space_comparison(clustering, trajectoryHandler,
                                    matrixHandler, clustering_parameters,
                                    refinement_parameters):

    #     clustering = Refiner(matrixHandler,
    #                          trajectoryHandler,
    #                          clustering_parameters,
    #                          refinement_parameters,
    #                          observer).run(clustering)

    traj_ranges = {}
    current = 0
    for i, pdb_source in enumerate(trajectoryHandler.sources):
        num_confs = pdb_source.get_info("number_of_conformations")
        traj_ranges["traj_%d" % i] = (current, current + num_confs - 1)
        current = current + num_confs

    decomposed_clusters = Separator.separate(clustering.clusters, traj_ranges)

    analysis = Analyzer.run(decomposed_clusters, matrixHandler.distance_matrix)

    return analysis
Beispiel #5
0
def conformational_space_comparison(clustering, matrixHandler,
                                    trajectoryHandler, clustering_parameters,
                                    refinement_parameters, observer):

    #     clustering = Refiner(matrixHandler,
    #                          trajectoryHandler,
    #                          clustering_parameters,
    #                          refinement_parameters,
    #                          observer).run(clustering)

    # TODO: testing
    traj_ranges = {}
    current = 0
    for i, pdb in enumerate(trajectoryHandler.pdbs):
        traj_ranges["traj_%d" % i] = (current,
                                      current + pdb["conformations"] - 1)
        current = current + pdb["conformations"]

    decomposed_clusters = Separator.separate(clustering.clusters, traj_ranges)

    analysis = Analyzer.run(decomposed_clusters, matrixHandler.distance_matrix)

    return analysis
Beispiel #6
0
    def test_analyze_clusters(self):

        expected_analysis = {
            'cluster_2': {
                'components': ['traj_A'],
                'global': {
                    'std': 0.5656854152679444,
                    'max': 1.4142135381698608,
                    'num_elements': 5,
                    'mean': 1.1313708305358887,
                    "traj_A": {
                        "max": 1.4142,
                        "mean": 1.1314,
                        "num_elements": 5,
                        "std": 0.5657
                    }
                }
            },
            'cluster_3': {
                'components': ['traj_B'],
                'global': {
                    'std': 0.56568541526794436,
                    'max': 1.4142135381698608,
                    'num_elements': 5,
                    'mean': 1.1313708305358887,
                    "traj_B": {
                        "max": 1.4142,
                        "mean": 1.1314,
                        "num_elements": 5,
                        "std": 0.5657
                    }
                }
            },
            'cluster_1': {
                'components': ['traj_A', 'traj_B', 'traj_C'],
                'centers_mean_diff': 5.6903559366861982,
                'global': {
                    'std': 1.5095995219901064,
                    'num_elements': 15,
                    'max': 5.385164737701416,
                    'overlap': 0.49575698403605678,
                    'traj_C': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'traj_A': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'traj_B': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'mean': 3.3646855751673379
                }
            }
        }

        analysis = {}
        Analyzer.analyze_clusters(self.separated_decomposed_clusters,
                                  self.matrix, analysis)
        self.maxDiff = None
        self.assertEqual(
            json.dumps(expected_analysis,
                       sort_keys=True,
                       indent=0,
                       separators=(',', ':')),
            json.dumps(analysis,
                       sort_keys=True,
                       indent=0,
                       separators=(',', ':')))
Beispiel #7
0
    def test_analyze_clusters(self):

        expected_analysis = {
            'cluster_2': {
                'components': ['traj_A'],
                'global': {
                    'std': 0.5656854152679444,
                    'max': 1.4142135381698608,
                    'num_elements': 5,
                    'mean': 1.1313708305358887,
                    "traj_A":{
                        "max":1.4142,
                        "mean":1.1314,
                        "num_elements":5,
                        "std":0.5657
                    }
                }
            },
            'cluster_3': {
                'components': ['traj_B'],
                'global': {
                    'std': 0.56568541526794436,
                    'max': 1.4142135381698608,
                    'num_elements': 5,
                    'mean': 1.1313708305358887,
                    "traj_B":{
                        "max":1.4142,
                        "mean":1.1314,
                        "num_elements":5,
                        "std":0.5657
                    }
                }
            },
            'cluster_1': {
                'components': ['traj_A', 'traj_B', 'traj_C'],
                'centers_mean_diff': 5.6903559366861982,
                'global': {
                    'std': 1.5095995219901064,
                    'num_elements': 15,
                    'max': 5.385164737701416,
                    'overlap': 0.49575698403605678,
                    'traj_C': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'traj_A': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'traj_B': {
                        'std': 0.56568541526794436,
                        'max': 1.4142135381698608,
                        'num_elements': 5,
                        'mean': 1.1313708305358887
                    },
                    'mean': 3.3646855751673379
                }
            }
        }

        analysis = {}
        Analyzer.analyze_clusters(self.separated_decomposed_clusters, self.matrix, analysis)
        self.maxDiff = None
        self.assertEqual(json.dumps(expected_analysis, 
                                        sort_keys = True, 
                                        indent = 0, 
                                        separators = (',', ':')), 
                             json.dumps(analysis,
                                        sort_keys = True, 
                                        indent = 0, 
                                        separators = (',', ':')))