def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
binsize = args.bin_size
a, b, c = args.cell_vectors
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
# Compute number of bins, grid
nbins = int(c // binsize)
grid = np.linspace(binsize, c - binsize, nbins)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(density)(u, binsize, block)
for block in blocks)
# Save results as .csv
df = pd.DataFrame({'z-coord': grid, 'density': np.mean(results, axis=0)})
df.to_csv('%s/%s.ldens' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
a, b, c = args.cell_vectors
thresholds = args.thresholds
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(hbonds)(u, thresholds, block)
for block in blocks)
# Average autocorrelation functions of (possibly) different length
results = tolerant.mean(results)
t = np.arange(len(results))
# Save results as .csv
df = pd.DataFrame({'time': t, 'autocorr': results})
df.to_csv('%s/%s_%s.hblifetime' % (DATA_PATH, base, thresholds[1]),
index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
n_bins = args.n_bins
a, b, c = args.cell_vectors
thresholds = args.thresholds
pair = args.pair
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(
delayed(rdf)(u, thresholds, n_bins, pair, block) for block in blocks)
# Average RDFs over all blocks
results = np.mean(results, axis=0)
# Save results as .csv
df = pd.DataFrame({'z-coord': results[0], 'rdf': results[1]})
df.to_csv('%s/%s.rdf' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
a, b, c = args.cell_vectors
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(hbonds)(
u, block) for block in blocks)
# Concatenate results
results = np.concatenate(results, axis=1)
# Save results (heights, accepted HBs, donated HBs) as .csv
df1 = pd.DataFrame(results[0])
df2 = pd.DataFrame(results[1])
df3 = pd.DataFrame(results[2])
df1.to_csv('%s/%s.heights' % (DATA_PATH, base), index=False)
df2.to_csv('%s/%s.acc_hb' % (DATA_PATH, base), index=False)
df3.to_csv('%s/%s.don_hb' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time()-t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
binsize = args.bin_size
species = args.species
n_species = args.n_species
a, b, c = args.cell_vectors
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Select appropriate sorting function based on input
if species == 'H3O+':
func = sort_acid
elif species == 'OH-':
func = sort_base
else:
quit('Species should be H3O+ or OH-')
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
# Compute number of bins, grid
n_bins = int(c // binsize)
z = np.linspace(binsize, c - binsize, n_bins)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(
delayed(ion_coord)(u, n_species, func, block) for block in blocks)
# Concatenate results
results = np.concatenate(results)
# Save raw data as .csv
df = pd.DataFrame({'z-coord': results[:, 0], 'cnum': results[:, 1]})
df.to_csv('%s/%s.ion_coord' % (DATA_PATH, base), index=False)
# Compute histogram (probability density)
hist, _ = np.histogram(results[:, 0],
bins=n_bins,
range=(0.0, c),
density=True)
# Save histogram as .csv
df = pd.DataFrame({'z-coord': z, 'density': hist})
df.to_csv('%s/%s.ions' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
n_bins = args.n_bins
a, b, c = args.cell_vectors
thresholds = args.thresholds
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(surface)(u, thresholds, block)
for block in blocks)
results = np.concatenate(results)
# Assuming square lateral cell dimensions
results[results > a] -= a
results[results < 0] += a
hist, _, _ = np.histogram2d(results[:, 0],
results[:, 1],
bins=n_bins,
range=[[0, a]] * 2,
density=True)
# Save results as .csv
df = pd.DataFrame(hist)
df.to_csv('%s/%s.sdist' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
n_bins = args.n_bins
a, b, c = args.cell_vectors
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(lsi)(u, block)
for block in blocks)
# Concatenate results
results = np.concatenate(results)
# Compute 2D histogram (heights vs LSI)
hist2d, _, _ = np.histogram2d(results[:, 0],
results[:, 1],
bins=(n_bins, 2 * n_bins),
density=True,
range=[[0, 0.3], [9.85, 42.65]])
# Save results as .csv
df = pd.DataFrame(hist2d)
df.to_csv('%s/%s.lsi' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
n_bins = args.n_bins
a, b, c = args.cell_vectors
thresholds = args.thresholds
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(delayed(triplet)(
u, a, thresholds, block) for block in blocks)
# Compute grid
grid = np.linspace(0, 180, n_bins)
# Concatenate results, compute histogram
results = np.concatenate(results)
hist, _ = np.histogram(np.rad2deg(np.arccos(results)), bins=n_bins,
range=(0, 180), density=True)
# Save results as .csv
df = pd.DataFrame({'angle': grid, 'density': hist})
df.to_csv('%s/%s_%s.triplet' % (DATA_PATH, base, thresholds[1]),
index=False)
print('\nProgram executed in %.0f seconds' % (time()-t0))
def main():
args = parse()
input = args.input
n_jobs = args.n_cpu
n_bins = args.n_bins
a, b, c = args.cell_vectors
n_species = args.n_species
CURRENT_PATH = path.dirname(path.realpath(__file__))
DATA_PATH = path.normpath(path.join(CURRENT_PATH, path.dirname(input)))
base = path.splitext(path.basename(input))[0]
# Initialize universe (time step 0.5 fs)
u = mda.Universe(input, dt=5e-4)
u.add_TopologyAttr('charges')
u.dimensions = np.array([a, b, c, 90, 90, 90])
# Split trajectory into blocks
blocks = trj2blocks.get_blocks(u, n_jobs)
print('Analyzing...')
results = Parallel(n_jobs=n_jobs)(
delayed(proton_transfer)(u, n_species, block) for block in blocks)
# Concatenate results, compute PT coordinate grid
results = np.concatenate(results)
delta = np.linspace(-1, 1, n_bins)
# Save raw data as .csv
df = pd.DataFrame({
'delta': results[:, 0],
'z-coord': results[:, 1],
'OO-dist': results[:, 2],
'cnum': results[:, 3]
})
df.to_csv('%s/%s.pt' % (DATA_PATH, base), index=False)
# Boolean indexing of protons in different layers
cond1 = np.logical_or(results[:, 1] < 13.95, results[:, 1] > 38.55)
cond2a = np.logical_and(results[:, 1] > 13.95, results[:, 1] < 18.05)
cond2b = np.logical_and(results[:, 1] > 34.45, results[:, 1] < 38.55)
cond2 = np.logical_or(cond2a, cond2b)
cond3a = np.logical_and(results[:, 1] > 18.05, results[:, 1] < 22.15)
cond3b = np.logical_and(results[:, 1] > 30.35, results[:, 1] < 34.45)
cond3 = np.logical_or(cond3a, cond3b)
cond4 = np.logical_and(results[:, 1] > 22.15, results[:, 1] < 30.35)
slice1 = results[cond1]
slice2 = results[cond2]
slice3 = results[cond3]
slice4 = results[cond4]
# Compute histograms for each layer (slice)
hist1, _ = np.histogram(slice1[:, 0],
bins=n_bins,
range=(-1, 1),
density=True)
hist2, _ = np.histogram(slice2[:, 0],
bins=n_bins,
range=(-1, 1),
density=True)
hist3, _ = np.histogram(slice3[:, 0],
bins=n_bins,
range=(-1, 1),
density=True)
hist4, _ = np.histogram(slice4[:, 0],
bins=n_bins,
range=(-1, 1),
density=True)
# Compute 2D histogram for whole data (height vs. PT coordinate)
hist2d, _, _ = np.histogram2d(results[:, 0],
results[:, 1],
bins=(n_bins, 2 * n_bins),
density=True,
range=[[-1, 1], [9.85, 42.65]])
# Save results as .csv
df = pd.DataFrame(hist2d)
df.to_csv('%s/%s.barrier2d' % (DATA_PATH, base), index=False)
df = pd.DataFrame({'delta': delta, 'density': hist1})
df.to_csv('%s/%s_13.95.barrier' % (DATA_PATH, base), index=False)
df = pd.DataFrame({'delta': delta, 'density': hist2})
df.to_csv('%s/%s_18.05.barrier' % (DATA_PATH, base), index=False)
df = pd.DataFrame({'delta': delta, 'density': hist3})
df.to_csv('%s/%s_22.15.barrier' % (DATA_PATH, base), index=False)
df = pd.DataFrame({'delta': delta, 'density': hist4})
df.to_csv('%s/%s_26.25.barrier' % (DATA_PATH, base), index=False)
print('\nProgram executed in %.0f seconds' % (time() - t0))
