def shrink_to_mols(self, mols): """Reduces the grid size to be just large enough to contain all mol objects in mol""" blank_grd = Grid.initalise_grid( [a.coordinates for l in mols for a in l.atoms]) for probe, g in self.super_grids.items(): self.super_grids[probe] = Grid.shrink(blank_grd, g)
def get_residue_vdw(self, residue, res_num, padding=3.0): """ generates a mask for the residue where points within VdW distance of residue heavy atoms are :param residue: `ccdc.prottein.Residue` :param res_num: The value which to assign to voxels in the masked area :param padding: float, padding around minimal coordinates in Angstroms :return: `hotspots.grid_extension.Grid` """ coords = np.array([a.coordinates for a in residue.atoms]) min_coords = (np.min(coords[:, 0]), np.min(coords[:, 1]), np.min(coords[:, 2])) max_coords = (np.max(coords[:, 0]), np.max(coords[:, 1]), np.max(coords[:, 2])) # Put some padding around the minimal and maximum values: g_origin = tuple(x - padding for x in min_coords) g_far_corner = tuple(y + padding for y in max_coords) layer = Grid(origin=g_origin, far_corner=g_far_corner, spacing=self.g_spacing, default=0.0, _grid=None) for a in residue.atoms: layer.set_sphere(point=a.coordinates, radius=a.vdw_radius, value=1, scaling='None') layer = self.set_uniform_values(layer, res_num) print("Size of layer: {}".format(layer.count_grid())) return layer
def augmentation(hr, hits): # create a grid which can contain all pharmacophore poses small_blank = Grid.initalise_grid(coords={ atm.coordinates for mol in hits.hits for atm in mol.molecule.heavy_atoms }, padding=3) # dilate the grids for p, g in hr.super_grids.items(): hr.super_grids[p] = g.dilate_by_atom() # inflate prot_g = Grid.initalise_grid( [a.coordinates for a in hr.protein.heavy_atoms], padding=1) for p, g in hr.super_grids.items(): hr.super_grids[p] = prot_g.common_boundaries(g) # shrink hotspot maps to save time sub_grids = { p: Grid.shrink(small=small_blank, big=g) for p, g in hr.super_grids.items() } # create single grid mask_dic, sg = Grid.get_single_grid(sub_grids) hr.super_grids = mask_dic # set background to 1 hr.set_background() hr.normalize_to_max() return hr
def create_atomic_hotspots(self, superstar_grids_dir): """ :param superstar_grids_dir: path to where the superstar grids are stored :return: """ atomic_hotspots = [] # Read in the SuperStar and Buriedness info probes = ['donor', 'acceptor', 'apolar', 'positive', 'negative'] b_grid = Grid.from_file( str(Path(superstar_grids_dir, 'buriedness.ccp4').resolve())) for p in probes: g_path = Path(superstar_grids_dir, f'superstar_{p}.ccp4') if g_path.exists(): print(f" found grid for probe of type {p}") p_grid = Grid.from_file(str(g_path.resolve())) ahs = _AtomicHotspotResult(identifier=p, grid=p_grid, buriedness=b_grid) atomic_hotspots.append(ahs) else: continue return atomic_hotspots
def test_output_grid(self): #g_0 = Grid.from_file(self.grid_paths[0]) g_0 = self.grid_list[0] print(g_0.count_grid()) print(self.max_grid.count_grid()) max_g, ref_g = Grid.common_grid([self.max_grid, g_0]) diff_grid = (max_g - ref_g) nx, ny, nz = diff_grid.nsteps for x in range(nx): for y in range(ny): for z in range(nz): if diff_grid.value(x, y, z) != 0: print(diff_grid.value(x, y, z)) self.assertEqual((max_g - ref_g).count_grid(), 0, msg="Testing the max_grid") means_grid = self.grid_ensemble.output_grid(mode="mean", save=False) mean_g, ref_g = Grid.common_grid([means_grid, g_0]) self.assertEqual((max_g - ref_g).count_grid(), 0, msg="Testing the means_grid") ranges_grid = self.grid_ensemble.output_grid(mode="ranges", save=False) self.assertEqual(ranges_grid.count_grid(), 0, msg="Testing the ranges grid") other_g = self.grid_ensemble.output_grid(mode="bla", save=False) self.assertIsNone(other_g)
def test_neighbourhood(self): # check the catchment critera neighbours = Grid.neighbourhood(i=0, j=0, k=0, high=self.buriedness.nsteps, catchment=1) self.assertEqual(3, len(neighbours)) neighbours1 = Grid.neighbourhood(i=5, j=5, k=5, high=self.buriedness.nsteps, catchment=1) self.assertEqual(6, len(neighbours1)) f = PyMOLFile() for i, n in enumerate(neighbours + neighbours1): f.commands += PyMOLCommands.sphere(f"sphere_{i}", (0, 0, 1, 1), n, 0.1) f.commands += PyMOLCommands.load_cgo(f"sphere_{i}", f"sphere_{i}_obj") f.commands += PyMOLCommands.sphere("centre", (1, 0, 0, 1), (5, 5, 5), 0.1) f.commands += PyMOLCommands.load_cgo("centre", "centre_obj") f.commands += PyMOLCommands.sphere("centre1", (1, 0, 0, 1), (0, 0, 0), 0.1) f.commands += PyMOLCommands.load_cgo("centre1", "centre1_obj") f.write("testdata/grid_extension/neighbourhood.py")
def _as_grid(self, feature_type=None, tolerance=2): """ returns _features as grid """ if feature_type == None: filtered_features = self._features else: filtered_features = [ feat for feat in self._features if feat.feature_type == feature_type ] x = [feat.feature_coordinates.x for feat in filtered_features] y = [feat.feature_coordinates.y for feat in filtered_features] z = [feat.feature_coordinates.z for feat in filtered_features] origin = [min(x) - tolerance, min(y) - tolerance, min(z) - tolerance] far_corner = [ max(x) + tolerance, max(y) + tolerance, max(z) + tolerance ] grd = Grid(origin=origin, far_corner=far_corner, spacing=0.5, default=0, _grid=None) for feat in filtered_features: grd.set_sphere(point=feat.feature_coordinates, radius=self.settings.radius, value=1, scaling='None') return grd
def _generate_result(self, path): with PushDir(path): files = set(listdir(path)) # fetch protein - this should always be protein.pdb prot_name = [f for f in files if f.split(".")[1] == self.supported_protein_extensions][0] prot = Protein.from_file(prot_name) files.remove(prot_name) # there should only be one grid extension in the directory, if there are more # then you can manually read in your results grid_extension = {f.split(".")[1] for f in files}.intersection(self.supported_grid_extensions) if len(grid_extension) > 1: raise IndexError("Too many grid types, create `hotspots.result.Results` manually") elif len(grid_extension) < 1: raise IndexError("No supported grid types found") elif list(grid_extension)[0] == "dat": raise NotImplementedError("Will put this in if requested") else: grid_extension = list(grid_extension)[0] # read hotspot grids stripped_files = {f.split(".")[0] for f in files} hotspot_grids = stripped_files.intersection(self.supported_interactions) super_grids = {p: Grid.from_file(f"{p}.{grid_extension}") for p in hotspot_grids} # read superstar grids if len([f.startswith("superstar") for f in files]) > 0 and self.read_superstar: superstar_grids = {p: Grid.from_file(f"superstar_{p}.{grid_extension}") for p in hotspot_grids} else: superstar_grids = None # read weighted_superstar grids if len([f.startswith("weighted") for f in files]) > 0 and self.read_weighted: weighted_grids = {p: Grid.from_file(f"weighted_{p}.{grid_extension}") for p in hotspot_grids} else: weighted_grids = None # fetch buriedness grid try: buriedness_name = [f for f in files if f.startswith("buriedness")][0] except IndexError: buriedness_name = None if buriedness_name and self.read_buriedness: buriedness = Grid.from_file(buriedness_name) else: buriedness = None return Results(super_grids=super_grids, protein=prot, buriedness=buriedness, superstar=superstar_grids, weighted_superstar=weighted_grids, identifier=basename(path))
def _get_volume_overlap(self, cav_id, other_id, lig_id): """ find the highest median bcv from all cavities, calculate percentage over between the best bcv and each query ligand :return: """ def nonzero(val): if val == 0: return 1 else: return val # inputs mol = io.MoleculeReader(self.extracted_ligands[other_id][lig_id])[0] path1 = os.path.join(self.hotspot[cav_id], "out.zip") path2 = os.path.join(self.bcv[cav_id][other_id][lig_id], "out.zip") thresholds = [10, 14, 17] if os.path.exists(path1) and os.path.exists(path2): bcv = HotspotReader(path2).read() hot = HotspotReader(path1).read() # tasks other = Grid.from_molecule(mol) bcv_sg = Grid.get_single_grid(bcv.super_grids, mask=False) bcv_overlap = bcv_sg._mutually_inclusive(other=other).count_grid() lig_vol = (other > 0).count_grid() bcv_vol = (bcv_sg > 0).count_grid() hot_sgs = [(Grid.get_single_grid(hot.super_grids, mask=False) > t) for t in thresholds] hot_vols = [nonzero(hot_sg.count_grid()) for hot_sg in hot_sgs] hot_overlap = [hot_sg._mutually_inclusive(other=other).count_grid() for hot_sg in hot_sgs] # output with open(self.bcv_lig_overlaps[cav_id][other_id][lig_id], 'w') as writer: writer.write(str((bcv_overlap / lig_vol) * 100)) with open(self.bcv_hot_overlaps[cav_id][other_id][lig_id], 'w') as writer: writer.write(str((bcv_overlap / bcv_vol) * 100)) with open(self.hot_lig_overlaps[cav_id][other_id][lig_id], 'w') as writer: hot_lig = [str((a / lig_vol) * 100) for a in hot_overlap] print(hot_lig) writer.write(",".join(hot_lig)) with open(self.hot_hot_overlaps[cav_id][other_id][lig_id], 'w') as writer: hot_hot = [str((hot_overlap[i] / hot_vols[i]) * 100) for i in range(len(thresholds))] writer.write(",".join(hot_hot)) else: print("no BCV for cavity {}, BCV {}".format(cav_id, lig_id))
def make_max_difference_maps(io): probes = ["donor", "acceptor", "apolar"] for probe in probes: g1 = Grid.from_file( join(io.ensemble_dirs[e1], "{}_{}_max.ccp4".format(e1, probe))) g2 = Grid.from_file( join(io.ensemble_dirs[e2], "{}_{}_max.ccp4".format(e2, probe))) diff_g = g1 - g2 diff_g.write( join(io.params.pipeline_root, "diff_{}_{}_{}.ccp4").format(e1, e2, probe))
def make_grid(offset, vals, idxs, nsteps): grid_origin = offset grid_far_corner = ( offset[0] + (nsteps[0] - 1) * 0.5, offset[1] + (nsteps[1] - 1) * 0.5, offset[2] + (nsteps[2] - 1) * 0.5) out_grid = Grid(origin=grid_origin, far_corner=grid_far_corner, spacing=0.5, _grid=None, default=0) for (nx, ny, nz), v in zip(idxs, vals): # print(nx, ny, nz, v) # print(int(nx-offset[0]*2), int(ny-offset[1]*2), int(nz-offset[2]*2)) out_grid.set_value(int(nx - offset[0] * 2), int(ny - offset[1] * 2), int(nz - offset[2] * 2), v) return out_grid
def generate_fake(self, buriedness=False, weighted=False, superstar=True): """ create a small set of grids for testing :param buriedness: :param weighted: :param superstar: :return: """ def populate_grid(template, num_spheres, radius=1, value=8, scaling='linear'): h = template.copy_and_clear() for i in range(1, num_spheres): x, y, z = [np.random.randint(low=2, high=ax - 2, size=1) for ax in h.nsteps] h.set_sphere(point=h.indices_to_point(x, y, z), radius=radius, value=value, scaling=scaling) return h protein = Protein.from_file("testdata/6y2g_A/binding_site.pdb") mol = MoleculeReader("testdata/6y2g_A/A_mol.mol2")[0] g = Grid.initalise_grid([a.coordinates for a in mol.atoms]) if buriedness: buriedness_grid = Grid.from_molecule(mol) else: buriedness_grid = None interactions = ["apolar", "donor", "acceptor"] super_grids = {p: populate_grid(template=g, num_spheres=3) for p in interactions} if superstar: superstar_grids = {p: populate_grid(template=g, num_spheres=3) for p in interactions} else: superstar_grids = None if weighted: weighted_superstar_grids = {p: populate_grid(template=g, num_spheres=3) for p in interactions} else: weighted_superstar_grids = None return Results(super_grids=super_grids, protein=protein, buriedness=buriedness_grid, superstar=superstar_grids, weighted_superstar=weighted_superstar_grids)
def buriedness_grid(self): closed_g = self._multiscale_closing(self.protein_grid) out_g = self._open_grid(closed_g, 2) * closed_g out_array = out_g.get_array() scaled_g = Grid.initalise_grid(self.out_grid.bounding_box, padding=0, spacing=0.5) scaled_array = resize(out_array, scaled_g.nsteps, anti_aliasing=False) # Future tweaking here final_array = scaled_array return Grid.array_to_grid(final_array.astype(int), scaled_g)
def grid_from_protein(self): """ Puts the protein inside a CCDC Grid object :return: a :class: hotspots.grid_extension.Grid instance """ if not self.protein: self.get_protein() coords = np.array([ a.coordinates for res in self.protein.residues for a in res.atoms ]) min_coords = (np.min(coords[:, 0]), np.min(coords[:, 1]), np.min(coords[:, 2])) max_coords = (np.max(coords[:, 0]), np.max(coords[:, 1]), np.max(coords[:, 2])) # Put some padding around the minimal and maximum values: g_origin = tuple(x - 3.0 for x in min_coords) g_far_corner = tuple(y + 3.0 for y in max_coords) prot_grid = Grid(origin=g_origin, far_corner=g_far_corner, spacing=self.g_spacing, default=0.0, _grid=None) return prot_grid
def as_grid(origin_coords, far_corner_coords, array, spacing=0.5): """ Given an array, outputs a grid with the dimensions of the GridEnsemble :param array: 3D numpy array, usually containing processed ensemble data :return: a :class: 'ccdc.utilities.Grid' instance """ # Initialise the Grid grid = Grid(origin=origin_coords, far_corner=far_corner_coords, spacing=spacing, default=0.0, _grid=None) # Get the nonzero indices and values of the array nonz = array.nonzero() values = array[nonz] # Get indices per value as_triads = zip(*nonz) # Fill in the grid for (i, j, k), v in zip(as_triads, values): grid._grid.set_value(int(i), int(j), int(k), v) return grid
def _molecule_as_grid(mol, g=None): """ Produces a grid representation of a molecule split by interaction type :param mol: takes any ccdc molecule :type mol: `ccdc.molecule.Molecule` :param g: a blank grid :type g: `hotspots.grid_extension.Grid` :return: a dictionary of grids by interaction type :rtype: dict """ if not g: g = Grid.initalise_grid(coords=[a.coordinates for a in mol.atoms], padding=3) grid_dict = {"donor": g.copy(), "acceptor": g.copy(), "apolar": g.copy()} for p, g in grid_dict.items(): atms = [a for a in mol.atoms if Helper.get_atom_type(a) == p] for atm in atms: g.set_sphere(point=atm.coordinates, radius=atm.vdw_radius, value=1, scaling='None') return grid_dict
def _from_molecule(self, mol, scaling=1): """ generate a molecule mask where gp within the vdw radius of the molecule heavy atoms are set to 1.0 :param mol: `ccdc.molecule.Molecule` :param padding: int :param scaling: float :return: `hotspots.grid_extension.Grid` """ coords = [a.coordinates for a in mol.atoms] g = Grid.initalise_grid(coords=coords, padding=15, spacing=1) for probe in sorted(self.probe_selem_dict.keys(), reverse=True): for a in mol.heavy_atoms: g.set_sphere(point=a.coordinates, radius=probe * scaling, value=probe, mode='replace', scaling='None') for a in mol.heavy_atoms: g.set_sphere(point=a.coordinates, radius=a.vdw_radius, value=100, mode='replace', scaling='None') out_bound_box = self.out_grid.bounding_box origin_indices = g.point_to_indices(out_bound_box[0]) far_indices = g.point_to_indices(out_bound_box[1]) region = origin_indices + far_indices print(region) return g.sub_grid(region)
def make_difference_maps(self): """ Brings the two results to the same size and subtracts them. TODO - think about cases of results with different numbers of probe grids (charged vs not) :return: ccdc grids """ diff_maps = {} for probe, gr in self.target.super_grids.items(): try: off_gr = self.off_target.super_grids[probe] # In case the off-target hotspot result doesn't have a map for that probe except KeyError: continue # if gr.check_same_size_and_coords(off_gr): # c_gr = gr # c_off = off_gr # else: # print("Input grids of different size. Converting to same coordinates.") c_gr, c_off = Grid.common_grid([gr, off_gr]) diff_maps[probe] = _GridEnsemble.array_from_grid(c_gr - c_off) self.common_grid_dimensions = np.array(c_gr.bounding_box) self.common_grid_nsteps = c_gr.nsteps return diff_maps
def tractability_workflow(protein, tag): """ A very simple tractability workflow. :param str protein: PDB identification code :param str tag: Tractability tag: either 'druggable' or 'less-druggable' :return: `pandas.DataFrame` """ # 1) calculate Fragment Hotspot Result runner = Runner() result = runner.from_pdb(pdb_code=protein, nprocesses=1, buriedness_method='ghecom') # 2) calculate Best Continuous Volume extractor = Extractor(hr=result) bcv_result = extractor.extract_volume(volume=500) # 3) find the median score grid = Grid.get_single_grid(bcv_result.super_grids, mask=False) values = grid.grid_values(threshold=5) median = np.median(values) # 4) return the data return pd.DataFrame({ 'scores': values, 'pdb': [protein] * len(values), 'median': [median] * len(values), 'tractability': [tag] * len(values), })
def __init__(self, hr, settings=None): if settings is None: self.settings = self.Settings() else: self.settings = settings self._single_grid = None self._masked_dic = None self.out_dir = None self.extracted_hotspots = None self.threshold = None try: hr.super_grids["negative"] = hr.super_grids[ "negative"].deduplicate(hr.super_grids["acceptor"], threshold=10, tolerance=2) hr.super_grids["positive"] = hr.super_grids[ "positive"].deduplicate(hr.super_grids["donor"], threshold=10, tolerance=2) except KeyError: pass self.hotspot_result = hr self._masked_dic, self._single_grid = Grid.get_single_grid( self.hotspot_result.super_grids)
def _grow(self, tolerance=0.2): """ A single grid is iteratively inflated, and the top 20% of neighbouring grid points added until the volume is with the tolerance of the target volume. :param float tolerance: allowable error in volume extraction :return float: threshold """ self.best_island = self._single_grid.common_boundaries( self.best_island) current_num_gp = self.best_island.count_grid() f = 0 while f < 100 and abs( ((self.settings._num_gp - current_num_gp) / self.settings._num_gp )) > tolerance and self.settings._num_gp >= current_num_gp: grown = Grid.grow(self.best_island, self.single_grid) self.best_island = grown current_num_gp = self.best_island.count_grid() print(current_num_gp, 'out of', self.settings._num_gp) f += 1 tmp_best_island = self.best_island * self.single_grid g_vals = tmp_best_island.grid_values() g_vals[::-1].sort() try: threshold = g_vals[self.settings._num_gp] except IndexError: threshold = min(g_vals) # assert abs(((self.settings._num_gp - current_num_gp) / self.settings._num_gp)) < tolerance return threshold
def _create_grids(pharmacophores): g = Grid.initalise_grid(coords=[ s.centre for p in pharmacophores for f in p.features for s in f.spheres ], spacing=0.5) fds = {f.identifier for p in pharmacophores for f in p.features} return {fd: g.copy() for fd in fds}
def create_projection_grid(self): """ create the projected spheres for the summary pharmacophore features :return: `hotspots.grid_extension.Grid` """ # Do the features have projections ? if len([f for f in self.features if len(f.spheres) > 1]) == 0: return None else: g = Grid.initalise_grid(coords=[ feature.spheres[1].centre for feature in self.features ], spacing=0.25, padding=2) for f in self.features: if len(f.spheres) > 1: px, py, pz = [ f.spheres[1].centre[0], f.spheres[1].centre[1], f.spheres[1].centre[2] ] g.set_sphere(point=[px, py, pz], value=1, radius=2, scaling='linear') self.projection_grid = g return g
def make_thresholded_maps(io, e1, e2): """ :param io: EnsembleIO instance. :param str ens1: name of reference ensemble :param str ens2: name of off-target ensemble :return: """ t_dir = join(io.params.pipeline_root, "thresholded_hotspot_maps") if not exists(t_dir): os.mkdir(t_dir) print(t_dir) probes = ["donor", "acceptor", "apolar"] for probe in probes: ge1 = pickle.load(open(io.ensemble_maps[e1][probe], "r")) ge2 = pickle.load(open(io.ensemble_maps[e2][probe], "r")) iarr = ge1.get_difference_map(ge2, tolerance=0) diff = Grid.from_file( join(io.params.pipeline_root, "diff_{}_{}_{}.ccp4").format(e1, e2, probe)).get_array() over3 = (iarr > 3) * diff gover3 = ge1.save_grid(over3) gover3.write( join(t_dir, "diff_{}_{}_{}_over3.ccp4".format(e1, e2, probe))) under3 = (iarr < 3) * diff gunder3 = ge1.save_grid(under3) gunder3.write( join(t_dir, "diff_{}_{}_{}_under3.ccp4".format(e1, e2, probe)))
def test_features_to_grid(self): pm = PharmacophoreModel() pm.feature_definitions = ["acceptor"] pts = [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [2.5, 2.5, 2.5], [3.5, 3.5, 3.5]] g = Grid.initalise_grid(pts, padding=3) features = [ Feature(pm.feature_definitions["acceptor"], GeometricDescriptors.Sphere(centre=p, radius=1)) for p in pts ] for f in features: f.point = f.spheres[0] h = _features_to_grid(features, g) # should be 3 peaks, all with a value of 1.0 self.assertEqual(3, len(h.get_peaks(min_distance=1, cutoff=0))) self.assertTrue( all([ h.value_at_point(peak) == 1.0 for peak in h.get_peaks(min_distance=1, cutoff=0) ]))
def test_write_real_single(self): base = "testdata/1hcl" interactions = ["donor", "acceptor", "apolar"] super_grids = {p: Grid.from_file(os.path.join(base, f"{p}.grd")) for p in interactions} superstar_grids = {p: Grid.from_file(os.path.join(base, f"superstar_{p}.grd")) for p in interactions} buriedness = Grid.from_file(os.path.join(base, "buriedness.grd")) prot = Protein.from_file(os.path.join(base, "protein.pdb")) hr = Results(super_grids=super_grids, protein=prot, buriedness=buriedness, superstar=superstar_grids) settings = HotspotWriter.Settings() settings.output_superstar = True with HotspotWriter("testdata/hs_io/minimal_all_grids_real", settings=settings) as w: w.write(hr)
def set_background(self, background_value=1.0): spacing = self.super_grids["apolar"]._spacing prot_g = Grid.from_molecule(self.protein, value=background_value, scaling_type='none', scaling=1, spacing=spacing) for probe, g in self.super_grids.items(): common_prot, common_g = Grid.common_grid([prot_g, g]) bg_mask = (common_prot < 0.1) & (common_g < 1) tmp_g = common_g + bg_mask new_g = tmp_g - (common_prot) origin, corner = g.bounding_box i, j, k = new_g.point_to_indices(origin) l, m, n = new_g.point_to_indices(corner) self.super_grids[probe] = new_g.sub_grid((i, j, k, l, m, n))
def __init__(self, settings): self.settings = settings if self.settings.out_grid: self.grid = self.settings.out_grid else: self.grid = Grid.initalise_grid([atom.coordinates for atom in self.settings.protein.atoms], padding=2) self.update_grid()
def _get_grids(self, sub_dir=None): """ create a grid dictorionary :return: """ if sub_dir: base = join(self._base, sub_dir) self._files = listdir(base) self._extensions = set( [splitext(f)[1] for f in self._files if f != '' or f != '.py']) else: base = self._base if ".dat" in self._extensions: grid_dic = { splitext(fname)[0]: Grid.from_array(join(base, fname)) for fname in [ f for f in self._files if splitext(f)[1] == ".grd" and splitext(f)[0] in self._supported_interactions ] } try: buriedness = Grid.from_array(join(self.base, "buriedness.dat")) except RuntimeError: buriedness = None else: ext = list( set(self._extensions).intersection(self._supported_grids)) if len(ext) == 1: grid_dic = { splitext(fname)[0]: Grid.from_file(join(base, fname)) for fname in [ f for f in self._files if splitext(f)[1] == ext[0] and splitext(f)[0] in self._supported_interactions ] } try: buriedness = Grid.from_file("buriedness{}".format(ext[0])) except RuntimeError: buriedness = None else: raise RuntimeError("Opps, something went wrong.") return grid_dic, buriedness
def score_hotspot(self, threshold=5, percentile=50): """ Hotspot scored on the median value of all points included in the hotspot. NB: grid point with value < 5 are ommited from fragment hotspot map (hence the default threshold) :param percentile: :return: """ sg = Grid.get_single_grid(self.hotspot_result.super_grids, mask=False) return sg.grid_score(threshold=threshold, percentile=percentile)