def test_write_dx(tmpdir, nptype, dxtype, counts=100, ndim=3): # conversion from numpy array to DX file h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) # hack the grid to be a different dtype g.grid = g.grid.astype(nptype) assert_equal(g.grid.sum(), counts) with tmpdir.as_cwd(): outfile = "grid.dx" g.export(outfile) g2 = Grid(outfile) # check that dxtype was written dx = gridData.OpenDX.field(0) dx.read(outfile) data = dx.components['data'] out_dxtype = data.type assert_almost_equal(g.grid, g2.grid, err_msg="written grid does not match original") assert_almost_equal( g.delta, g2.delta, decimal=6, err_msg="deltas of written grid do not match original") assert_equal(out_dxtype, dxtype)
def __init__(self, fileName): try: from gridData import Grid except ModuleNotFoundError: raise ModuleNotFoundError("The dependency 'GridDataFormats' is required for this functionality!") self.grid = Grid(fileName) # stores the grid data
def mask_generator(maskfile, referencefile=None, distance=5): if os.path.splitext(maskfile)[1] == ".pdb": mask = GridUtil.gen_distance_grid(referencefile, maskfile) else: mask = Grid(maskfile) mask.grid = mask.grid < distance return mask
def test_centers(self, data): # this only checks the edges. If you know an alternative # algorithm that isn't an exact duplicate of the one in # g.centers to test this please implement it. g = Grid(data['griddata'], origin=np.ones(3), delta=data['delta']) centers = np.array(list(g.centers())) assert_array_equal(centers[0], g.origin) assert_array_equal(centers[-1] - g.origin, (np.array(g.grid.shape) - 1) * data['delta'])
def test_load_pickle(self, data, tmpdir): g = data['grid'] fn = str(tmpdir.mkdir('grid').join('grid.pkl')) g.save(fn) h = Grid() h.load(fn) assert h == g
def test_pickle(self, data, tmpdir): g = data['grid'] fn = str(tmpdir.mkdir('grid').join('grid.pkl')) g.save(fn) h = Grid() h.load(fn, file_format="pickle") assert h == g
def test_write_dx_ValueError(tmpdir, nptype, outfile, counts=100, ndim=3): h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) # hack the grid to be a different dtype g.grid = g.grid.astype(nptype) with pytest.raises(ValueError): with tmpdir.as_cwd(): g.export(outfile)
def test_write_dx_ValueError(tmpdir, nptype, counts=100, ndim=3): h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) # hack the grid to be a different dtype g.grid = g.grid.astype(nptype) with pytest.raises(ValueError): with tmpdir.as_cwd(): outfile = "grid.dx" g.export(outfile)
def test_read_dx(): g = Grid('gridData/tests/test.dx') POINTS = 8 assert_array_equal(g.grid.flat, np.ones(POINTS)) assert_equal(g.grid.size, POINTS) assert_array_equal(g.delta, np.ones(3)) assert_array_equal(g.origin, np.zeros(3))
def test_ccp4(): g = Grid('gridData/tests/test.ccp4') POINTS = 192 assert_equal(g.grid.flat, np.arange(1, POINTS + 1)) assert_equal(g.grid.size, POINTS) assert_almost_equal(g.delta, [3. / 4, .5, 2. / 3]) assert_equal(g.origin, np.zeros(3))
def test_ccp4(): g = Grid(datafiles.CCP4) POINTS = 192 assert_equal(g.grid.flat, np.arange(1, POINTS+1)) assert_equal(g.grid.size, POINTS) assert_almost_equal(g.delta, [3./4, .5, 2./3]) assert_equal(g.origin, np.zeros(3))
def extractISOPdb(input, output, iso): g = Grid(input) # JD: this is clunky but i'm not sure what's a better way data = np.array(OpenDX.array(3, g.grid).array.flat) data = data.reshape((len(data) / 3, 3)) x, y, z = 0, 0, 0 counter = 1 lines = [] for point in data: for pos in point: if (iso < 0 and pos < iso) or (iso > 0 and pos > iso): line = 'ATOM %5d C PTH 1 %8.3f%8.3f%8.3f%6.2f%6.2f\n' % ( counter, g.origin[0] + float(x) * g.delta[0, 0], g.origin[1] + float(y) * g.delta[1, 1], g.origin[2] + float(z) * g.delta[2, 2], 0.0, 0.0) lines.append(line) counter += 1 z += 1 if z >= g.grid.shape[2]: z = 0 y += 1 if y >= g.grid.shape[1]: y = 0 x += 1 with open(output, "w") as f: f.writelines(lines) return g
def analyze_dx(_f): """analyzes dx _file Args: _f (string): filename with extension of the dx file that we want to analyze Returns: pandas: pandas dataframe columns=['coord_phi','phiz'] """ g = Grid(_f) nx, ny, nz = g.grid.shape Lx = g.edges[0][0] Ly = g.edges[1][0] Lzl = g.edges[2][0] Lzr = g.edges[2][-1] g_all = np.zeros(nz) count = 0 for i in range(nx): for j in range(ny): g_all += g.grid[i][j] count += 1 r_array = np.linspace(Lzl, Lzr, nz) yy = g_all / count A = np.vstack([r_array, yy]) df = pd.DataFrame(A.T, columns=['coord_phi', 'phiz']) return df
def analyze_dx(f): """analyzes dx file""" g = Grid(f + ".dx") nx, ny, nz = g.grid.shape Lx = g.edges[0][0] Ly = g.edges[1][0] Lzl = g.edges[2][0] Lzr = g.edges[2][-1] # g_all = g.grid[nx//2][ny//2] # g_vmd = g_all # L = 100. g_all = np.zeros(nz) count = 0 for i in range(nx): for j in range(ny): g_all += g.grid[i][j] count += 1 # vmd_unit = 25*ureg.mV # vmd_unit = 1. # units = nu.e/(25*nu.mV) # print units yy = g_all[2:-2]/count r_array = np.linspace(Lzl, Lzr, len(yy)) print len(r_array), len(yy) return r_array, yy
def test_init_pickle_pathobjects(self, data, tmpdir): g = data['grid'] fn = tmpdir.mkdir('grid').join('grid.pickle') g.save(fn) h = Grid(fn) assert h == g
def test_write_dx(counts=100, ndim=3): h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) assert_equal(g.grid.sum(), counts) with tempdir.in_tempdir(): outfile = "grid.dx" g.export(outfile) g2 = Grid(outfile) assert_array_almost_equal(g.grid, g2.grid, err_msg="written grid does not match original") assert_array_almost_equal( g.delta, g2.delta, err_msg="deltas of written grid do not match original")
def data(): d = dict( griddata=np.arange(1, 28).reshape(3, 3, 3), origin=np.zeros(3), delta=np.ones(3)) d['grid'] = Grid(d['griddata'], origin=d['origin'], delta=d['delta']) return d
def read_APBS(self): ''' Read the APBS output. Returns ------- charge : array The three-dimensional array of the charge density. diel : array The three-dimensional array of the dielectric constant in the x direction. lipid : array The three-dimensional array of the ESP. ''' charge = Grid('charge_check.dx').grid diel = Grid('dielx_check.dx').grid lipid = Grid('lipid.dx').grid return charge, diel, lipid
def _conclude(self): # concatenate lists into arrays all_coords = np.concatenate(self.coord_list, axis=0) # compute histogram self.data, self.edges = np.histogramdd( all_coords, [self.xedges, self.yedges, self.zedges]) # normalize to occupancy per frame self.data = self.data / self.frame_count # place into a grid object for writing to .dx self.gridobj = Grid(self.data, edges=self.edges)
def test_anyarray(data): ma = np.ma.MaskedArray(data['griddata']) mg = Grid(ma, origin=data['origin'], delta=data['delta']) assert isinstance(mg.grid, ma.__class__) result = f_arithmetic(mg) ref = f_arithmetic(data['grid']) assert_almost_equal(result.grid, ref.grid)
def test_read_dx(infile): g = Grid(infile) POINTS = 8 ref = np.ones(POINTS) ref[4] = 1e-6 ref[5] = -1e+6 assert_equal(g.grid.flat, ref) assert_equal(g.grid.size, POINTS) assert_equal(g.delta, np.ones(3)) assert_equal(g.origin, np.array([20.1, 3., -10.]))
def get_density(lipid_xyz, ul_max, x): xbin, ybin, zbin = int(ul_max[0]*x), int(ul_max[1]*x), int(ul_max[2]*x) system_h, system_e = coordinate_histogram(lipid_xyz, xbin, ybin, zbin) histogram, edges = system_h, system_e grid = Grid(histogram, edges=[e * 10 for e in edges]) return grid
def read(self): DX = Path(self.fname).glob("*.dx") files = [p for p in DX if p.is_file()] if not files: raise Exception("No .dx files found") for dx in files: name = dx.stem.split('.') if (name[0].endswith("_"+self.suffix[0])): self.grids[self.suffix[0]+name[1]] = Grid(self.fname + "/" + dx.stem + ".dx") self.delta = np.prod(self.grids[self.suffix[0]+name[1]].delta) elif (name[0].endswith("_"+self.suffix[1])): self.grids[self.suffix[1]+name[1]] = Grid(self.fname + "/" + dx.stem + ".dx") elif (name[0].endswith("_"+self.suffix[2])): self.grids[self.suffix[2]+name[1]] = Grid(self.fname + "/" + dx.stem + ".dx") elif (name[0].endswith("_"+self.suffix[3])): self.grids[self.suffix[3]+name[1]] = Grid(self.fname + "/" + dx.stem + ".dx") if not self.grids: raise Exception("No tagged .dx files found")
class Interpolator(object): def __init__(self, fileName): try: from gridData import Grid except ModuleNotFoundError: raise ModuleNotFoundError("The dependency 'GridDataFormats' is required for this functionality!") self.grid = Grid(fileName) # stores the grid data def __call__(self, xyz): return self.grid.interpolated(xyz[:,0], xyz[:,1], xyz[:,2])
def _test_write_dx(counts=100, ndim=3, nptype="float32", dxtype="float"): h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) # hack the grid to be a different dtype g.grid = g.grid.astype(nptype) assert_equal(g.grid.sum(), counts) with tempdir.in_tempdir(): outfile = "grid.dx" g.export(outfile) g2 = Grid(outfile) # check that dxtype was written dx = gridData.OpenDX.field(0) dx.read(outfile) data = dx.components['data'] out_dxtype = data.type assert_almost_equal(g.grid, g2.grid, err_msg="written grid does not match original") assert_almost_equal( g.delta, g2.delta, decimal=6, err_msg="deltas of written grid do not match original") assert_equal(out_dxtype, dxtype)
def test_write_dx(tmpdir, nptype, dxtype, outfile, counts=100, ndim=3): # conversion from numpy array to DX file h, edges = np.histogramdd(np.random.random((counts, ndim)), bins=10) g = Grid(h, edges) # hack the grid to be a different dtype g.grid = g.grid.astype(nptype) assert_equal(g.grid.sum(), counts) with tmpdir.as_cwd(): g.export(outfile) g2 = Grid(outfile) # check that dxtype was written dx = gridData.OpenDX.field(0) dx.read(outfile) data = dx.components['data'] out_dxtype = data.type assert_almost_equal(g.grid, g2.grid, err_msg="written grid does not match original") assert_almost_equal(g.delta, g2.delta, decimal=6, err_msg="deltas of written grid do not match original") assert_equal(out_dxtype, dxtype)
def Grid(self, delta, **kwargs): """Package the PMF as a :class:`gridData.Grid` object. *delta* should be the original spacing of the points in angstroem. With a *resample_factor*, the data are interpolated on a new grid with *resample_factor* times as many bins as in the original histogram (See :meth:`gridData.Grid.resample_factor`). *interpolation_order* sets the interpolation order for the resampling procedure. .. Warning:: Interpolating can lead to artifacts in the 3D PMF. If in doubt, **do not resample**. """ from gridData import Grid resample_factor = kwargs.pop('resample_factor', None) kwargs.setdefault('interpolation_spline_order', 3) g = Grid(*self.histogramdd(delta), **kwargs) if not resample_factor: return g return g.resample_factor(resample_factor)
def read_central_ESP(self): ''' Read the one-dimensional ESP along the Z-axis at the center of the x-y plane. Returns ------- out_ESP : array The one-dimensional ESP. ''' lipid = Grid('lipid.dx').grid out_ESP = lipid[int(np.rint(self.grid[0] / 2)), int(np.rint(self.grid[1] / 2)), :] return out_ESP
def grid_to_dx(self, save_dir, grid, bin_size, use_channel_names=False): #origin = np.array([7.473, 4.334, 7.701]) - 5.0 if grid.shape[0] % 2 != 0: raise ValueError('Number of channels must be even (%i)' % grid.shape[0]) ch_per_mol = grid.shape[0] / 2 for shift, prefix in [(0, 'rec'), (ch_per_mol, 'lig')]: for ch in range(ch_per_mol): ch += shift if use_channel_names: names = self.prop_table.columns[1:] names *= 2 channel_name = names[ch] else: channel_name = str(ch) g = Grid(grid[ch], origin=np.array([7.473, 4.334, 7.701]) - 5.0, delta=bin_size) g.export(Path(save_dir).joinpath(channel_name + '.dx'), 'DX')
def density_data(self, dens, quantiles=np.arange(0, 1.05, 0.05)): g = Grid(dens) g_max = np.max(g.grid.flat) g_min = np.min(g.grid.flat) g_mean = np.median(g.grid.flat) g_std = np.std(g.grid.flat) filtered = g.grid[g.grid > 0.001] g_q = np.quantile(filtered.flat, q=quantiles) print(f'Mean: {g_mean}\nSt. dev: {g_std}\nMax: {g_max}\nMin: {g_min}') return (quantiles, g_q, g.grid, g_mean, g_std, g_max, filtered)
def test_gOpenMol(): g = Grid(datafiles.gOpenMol) POINTS = 192 assert g.grid.size == 165048 assert_almost_equal(g.delta, [1.0, 1.0, 1.0]) assert_equal(g.grid.shape, (46, 46, 78)) assert_almost_equal(g.origin, [0.5995016, 0.5995016, 0.5919984]) assert_almost_equal( g.grid[::20, ::20, ::30], np.array([[[1.02196848, 0., 0.88893718], [0.99051529, 0., 0.95906246], [0.96112466, 0., 0.88996845]], [[0.97247058, 0., 0.91574967], [1.00237465, 1.34423399, 0.87810922], [0.97917157, 0., 0.84717268]], [[0.99103099, 0., 0.86521846], [0.96421844, 0., 0.], [0.98432779, 0., 0.8817184]]])) assert_almost_equal(g.grid.mean(), 0.5403224581733577)
def test_equality(self, data): assert data['grid'] == data['grid'] assert data['grid'] != 'foo' g = Grid(data['griddata'], origin=data['origin'] + 1, delta=data['delta']) assert data['grid'] != g
class TestGrid: def __init__(self): self.griddata = np.arange(1, 28).reshape(3, 3, 3) self.origin = np.zeros(3) self.delta = np.ones(3) self.grid = Grid(self.griddata, origin=self.origin, delta=self.delta) def test_init(self): g = Grid(self.griddata, origin=self.origin, delta=1) assert_array_equal(g.delta, self.delta) @raises(TypeError) def test_init_wrong_origin(self): Grid(self.griddata, origin=np.ones(4), delta=self.delta) @raises(TypeError) def test_init_wrong_delta(self): Grid(self.griddata, origin=self.origin, delta=np.ones(4)) def test_equality(self): assert self.grid == self.grid assert self.grid != 'foo' g = Grid(self.griddata, origin=self.origin + 1, delta=self.delta) assert self.grid != g def test_addition(self): g = self.grid + self.grid assert_array_equal(g.grid.flat, (2 * self.griddata).flat) g = 2 + self.grid assert_array_equal(g.grid.flat, (2 + self.griddata).flat) g = g + self.grid assert_array_equal(g.grid.flat, (2 + (2 * self.griddata)).flat) def test_substraction(self): g = self.grid - self.grid assert_array_equal(g.grid.flat, np.zeros(27)) g = 2 - self.grid assert_array_equal(g.grid.flat, (2 - self.griddata).flat) def test_multiplication(self): g = self.grid * self.grid assert_array_equal(g.grid.flat, (self.griddata ** 2).flat) g = 2 * self.grid assert_array_equal(g.grid.flat, (2 * self.griddata).flat) def test_division(self): # __truediv__ is used in py3 by default and py2 if division # is imported from __future__ to make testing easier lets call # them explicitely g = self.grid.__truediv__(self.grid) assert_array_equal(g.grid.flat, np.ones(27)) g = self.grid.__rtruediv__(2) assert_array_equal(g.grid.flat, (2 / self.griddata).flat) def test_old_division(self): # this is normally ONLY invoked in python 2. To have test # coverage in python3 as well call it explicitely g = self.grid.__div__(self.grid) assert_array_equal(g.grid.flat, np.ones(27)) g = self.grid.__rdiv__(2) assert_array_equal(g.grid.flat, (2 / self.griddata).flat) def test_power(self): g = self.grid ** 2 assert_array_equal(g.grid.flat, (self.griddata ** 2).flat) g = 2 ** self.grid assert_array_equal(g.grid.flat, (2 ** self.griddata).flat) def test_compatibility_type(self): assert self.grid.check_compatible(self.grid) assert self.grid.check_compatible(3) g = Grid(self.griddata, origin=self.origin - 1, delta=self.delta) assert self.grid.check_compatible(g) @raises(TypeError) def test_wrong_compatibile_type(self): self.grid.check_compatible("foo") @raises(NotImplementedError) def test_non_orthonormal_boxes(self): delta = np.eye(3) Grid(self.griddata, origin=self.origin, delta=delta) def test_centers(self): # this only checks the edges. If you know an alternative # algorithm that isn't an exact duplicate of the one in # g.centers to test this please implement it. g = Grid(self.griddata, origin=np.ones(3), delta=self.delta) centers = np.array(list(g.centers())) assert_array_equal(centers[0], g.origin) assert_array_equal(centers[-1] - g.origin, (np.array(g.grid.shape) - 1) * self.delta) @dec.skipif(module_not_found('scipy'), "Test skipped because scipy is not available.") def test_resample_factor(self): g = self.grid.resample_factor(2) assert_array_equal(g.delta, np.ones(3) * .5) assert_array_equal(g.grid.shape, np.ones(3) * 6) # check that the edges are the same assert_array_almost_equal(g.grid[::5, ::5, ::5], self.grid.grid[::2, ::2, ::2])
import numpy as np from gridData import Grid import sys import argparse # one PMEpot unit (kT/e) of electrostatic potential is equivalent to 0.0258 Volts. (or 25.8 mV) # Parse inputs parser = argparse.ArgumentParser() parser.add_argument("-f",dest="infile",action="store") parser.add_argument("-e",dest="eField",type=float,action="store") parser.add_argument("-o",dest="outname",action="store") args = parser.parse_args() # Open the .dx from PMEPot, and calculate grid-demensions PMEPotIN = Grid(args.infile) lenx, leny, lenz = PMEPotIN.grid.shape # loop through the z-axis of the reaction potential and add the applied linear-potential for z in range(lenz): for x in range(lenx): for y in range(leny): PMEPotIN.grid[x][y][z] = PMEPotIN.grid[x][y][z] + (z*args.eField) # writeout new potential grid PMEPotIN.export(args.outname+'.dx')
def __init__(self): self.griddata = np.arange(1, 28).reshape(3, 3, 3) self.origin = np.zeros(3) self.delta = np.ones(3) self.grid = Grid(self.griddata, origin=self.origin, delta=self.delta)