def test_double_run(self):
# running rdf twice should give the same result
self._linear_water()
s1, s2 = self._get_sels()
rdf = InterRDF(s1, s2).run()
rdf.run()
assert_(len(rdf.count[rdf.count == 4]) == 2)
def test_nbins(self):
s1 = self.u.atoms[:3]
s2 = self.u.atoms[3:]
rdf = InterRDF(s1, s2, nbins=412)
assert_(len(rdf.bins) == 412)
def rdf(u, thresholds, n_bins, pair, block):
'''Computes water radial distribution functions (RDF).
Args:
u: MDAnalysis Universe object containing trajectory.
t: Thresholds specifying layer boundaries.
n_bins: Number of bins for RDF.
pair: Pair of elements to consider.
block: Range of frames composing block.
Returns:
Radial distribution function.
'''
atoms = list(pair)
# Select appropriate atom groups within specified layers
down = 'prop z > %s and prop z < %s' % (*thresholds[:2], )
up = 'prop z > %s and prop z < %s' % (*thresholds[2:], )
ag1 = u.select_atoms('name %s and ((%s) or (%s))' % (atoms[0], down, up),
updating=True)
ag2 = u.select_atoms('name %s' % atoms[1])
# Compute the RDF between ag1 and ag2
rdf = InterRDF(ag1, ag2, nbins=n_bins, range=(0, 6), verbose=True)
rdf.run(start=block.start, stop=block.stop)
return (rdf.results.bins, rdf.results.rdf)
def test_count_sum(self):
# OW vs HW
# should see 8 comparisons in count
self._linear_water()
s1, s2 = self._get_sels()
rdf = InterRDF(s1, s2).run()
assert_(rdf.count.sum() == 8)
def test_range(u):
s1 = u.atoms[:3]
s2 = u.atoms[3:]
rmin, rmax = 1.0, 13.0
rdf = InterRDF(s1, s2, range=(rmin, rmax)).run()
assert rdf.edges[0] == rmin
assert rdf.edges[-1] == rmax
def test_range(self):
s1 = self.u.atoms[:3]
s2 = self.u.atoms[3:]
rmin, rmax = 1.0, 13.0
rdf = InterRDF(s1, s2, range=(rmin, rmax)).run()
assert_(rdf.edges[0] == rmin)
assert_(rdf.edges[-1] == rmax)
def test_density(u, sels, density, value):
kwargs = {'density': density} if density is not None else {}
rdf = InterRDF_s(u, sels, **kwargs).run()
assert_almost_equal(max(rdf.rdf[0][0][0]), value)
if not density:
s1 = u.select_atoms('name ZND and resid 289')
s2 = u.select_atoms(
'name OD1 and resid 51 and sphzone 5.0 (resid 289)')
rdf_ref = InterRDF(s1, s2).run()
assert_almost_equal(rdf_ref.rdf, rdf.rdf[0][0][0])
def test_exclusion(self):
# should see two distances with 4 counts each
self._linear_water()
s1, s2 = self._get_sels()
rdf = InterRDF(s1, s2, exclusion_block=(1, 2))
rdf.run()
assert_(rdf.count.sum() == 4)
def test_count(self):
# should see two distances with 4 counts each
self._linear_water()
s1, s2 = self._get_sels()
rdf = InterRDF(s1, s2)
rdf.run()
assert_(len(rdf.count[rdf.count == 4]) == 2)
def rdf_mdanalysys(props):
rdfs = {}
for target in props['targets']:
rdfs[target] = InterRDF(g1=sel[props['ref']],
g2=sel[target],
start=ps_frame(props['start_ps'], DT),
stop=ps_frame(props['stop_ps'], DT),
verbose=True,
range=props['r_range'],
nbins=props['nbins'])
rdfs[target].run()
return rdfs
def setup(self, nbins, range_val):
self.sel_str = 'name OW'
self.u = MDAnalysis.Universe(TPR, XTC)
try:
self.sel = self.u.select_atoms(self.sel_str)[:200]
except AttributeError:
self.sel = self.u.selectAtoms(self.sel_str)[:200]
# do not include initialization of the
# InterRDF object in the benchmark itself
self.rdf = InterRDF(g1=self.sel,
g2=self.sel,
nbins=nbins,
range=range_val)
args = parse_command_line(sys.argv)
atom1 = "(segid %s and resid %s and name %s)" % \
(args.isegid1, args.iresid1, args.iname1)
atom2 = "(segid %s and resid %s and name %s)" % \
(args.isegid2, args.iresid2, args.iname2)
bins = int(args.inbins)
start = float(args.istart)
end = float(args.iend)
u = mda.Universe(args.ipdb, args.idcd, topology_format="PDB", format="DCD")
x = u.select_atoms(atom1)
y = u.select_atoms(atom2)
rdf = InterRDF(x, y, nbins=bins, range=(start, end))
rdf.run()
bins = rdf.bins
bins = np.around(bins, decimals=3)
RDF = rdf.rdf
zip(bins, RDF)
with open(args.output, 'w') as f:
writer = csv.writer(f, delimiter='\t')
writer.writerows(zip(bins, RDF))
with open(args.output) as f:
g = [xtmp.strip() for xtmp in f]
data = [tuple(map(float, xtmp.split())) for xtmp in g[0:]]
time = [xtmp[0] for xtmp in data]
rdf = [xtmp[1] for xtmp in data]
def compute_microstructure(molten_salt_system, ensemble, start, stop, step, nbins=500, rdf_flag=True, cn_flag=True, adf_flag=True):
"""
Description:
compute microstructure info including radial distribution fuction(rdf), coordination number(cn) and angle distribution function(adf) using MDAnalysis module. adf is not completed
Args:
molten_salt_system:
ensemble:
start:
stop:
step:
rdf_flag:
cn_flag:
adf_flag:
Returns:
return dicts according to setting
"""
global dir_molten_salt_system
global dir_list
# analysis elements and get cations and inions according cif file
os.chdir(dir_molten_salt_system)
cations_list, anions_list = [], []
with open(molten_salt_system+'.cif', 'r') as f_cif:
flag = False
atoms_list = []
for line in f_cif:
if line.startswith(' _atom_type_oxidation_number'):
flag = True
continue
if line.startswith('loop_'):
flag = False
continue
if flag:
tmp_tuple = tuple(list(filter(None, line.strip().split(' '))))
atoms_list.append(tmp_tuple)
for i in range(len(atoms_list)):
if float(atoms_list[i][1]) > 0:
cations_list.append((re.findall(r"[A-Za-z]+", atoms_list[i][0])[0]).upper()) # transfered to uppercase because MDAnalysis can just identify capitalization
elif float(atoms_list[i][1]) < 0:
anions_list.append((re.findall(r"[A-Za-z]+", atoms_list[i][0])[0]).upper())
elements_list = cations_list+anions_list
elements_count = len(elements_list)
# determine # of pairs(used in rdf and cn)
pairs_count = 0
for i in range(elements_count):
for j in range(i, elements_count):
pairs_count += 1
# radial_distribution_function_dense_dict, coordination_number_dense_dict= [{} for i in range(pairs_count)], [{} for i in range(pairs_count)] # 加密的
radial_distribution_function_dict, coordination_number_dict= [{} for i in range(pairs_count)], [{} for i in range(pairs_count)] # 原始的
for dirname in dir_list:
os.chdir(os.path.join(dir_molten_salt_system, dirname))
deal_with_PDB(dirname, ensemble) # write MODEL and ENDMDL into xxx.pdb file and stored as traj.pdb
universe = MDA.Universe('traj.pdb')
# determine cutoff of rdf
tmp_list = list(filter(None, os.popen('grep CRY '+dirname+'-'+ensemble+'.pdb').readlines()[-1].strip().split(' ')))
equilibrium_lattice_constant_a = float(tmp_list[1])
equilibrium_lattice_constant_b = float(tmp_list[2])
equilibrium_lattice_constant_c = float(tmp_list[3])
equilibrium_lattice_constant_min = min(equilibrium_lattice_constant_a, equilibrium_lattice_constant_b, equilibrium_lattice_constant_c)
cutoff = equilibrium_lattice_constant_min//2
# begin compute rdf and cn
columns_count = -1
for i in range(elements_count):
for j in range(i, elements_count):
columns_count += 1
atomgroup1 = universe.select_atoms('name '+elements_list[i])
atomgroup2 = universe.select_atoms('name '+elements_list[j])
rdf = InterRDF(atomgroup1, atomgroup2, nbins=nbins, range=(0.0, cutoff))
rdf.run(start=start, stop=stop, step=step) # after run, rdf and count have been generated
rdf.rdf[0] = 0 # 第一个数莫名奇妙的超级大，本该为0
# This part is discarded because of the limitation of 16MB for single file in mongodb
'''
# 加密10倍的
# store rdf results into a dict
# make curve smoother
rdf_new = np.linspace(rdf.bins.min(), rdf.bins.max(), nbins*10) # 加密十倍, 画出来的图更光滑
rdf_smooth = spline(rdf.bins, rdf.rdf, rdf_new)
# get rdf_rmax(first peak) and rdf_rmin(first peak valley) of rdf
rdf_rmax_index = np.argmax(rdf_smooth)
rdf_rmax = rdf_new[rdf_rmax_index]
rdf_rmin_index = np.argmin(rdf_smooth[rdf_rmax_index:])
rdf_rmin = rdf_new[rdf_rmax_index:][rdf_rmin_index]
radial_distribution_function_dense_dict[columns_count]['pair'] = elements_list[i]+'-'+elements_list[j]
radial_distribution_function_dense_dict[columns_count][dirname] = {'rdf_rmax': rdf_rmax, 'rdf_rmin': rdf_rmin, 'rdf_value': Binary(pickle.dumps(np.vstack((rdf_new, rdf_smooth)), protocol=2))} # numpy必须转换成二进制才能存进pymongo
# store cn results into a dict
rdf_count = rdf.count.copy()
rdf_count = rdf_count/(len(atomgroup1)*rdf.__dict__['n_frames']) # average
cn = rdf_count.cumsum() # integrate
# make curve smoother
cn_smooth = spline(rdf.bins, cn, rdf_new)
# get cn_rmin according to first peak valley in rdf
cn_rmin = cn_smooth[rdf_rmax_index:][rdf_rmin_index]
coordination_number_dense_dict[columns_count]['pair'] = elements_list[i]+'-'+elements_list[j]
coordination_number_dense_dict[columns_count][dirname] = {'cn_rmin': cn_rmin, 'cn_value': Binary(pickle.dumps(np.vstack((rdf_new, cn_smooth)), protocol=2))}
'''
# 原始的
# rdf
radial_distribution_function_dict[columns_count]['pair'] = elements_list[i]+'-'+elements_list[j]
radial_distribution_function_dict[columns_count][dirname] = Binary(pickle.dumps(np.vstack((rdf.bins, rdf.rdf)), protocol=2))
# cn
rdf_count = rdf.count.copy()
rdf_count = rdf_count/(len(atomgroup1)*rdf.__dict__['n_frames']) # average
cn = rdf_count.cumsum() # integrate
coordination_number_dict[columns_count]['pair'] = elements_list[i]+'-'+elements_list[j]
coordination_number_dict[columns_count][dirname] = Binary(pickle.dumps(np.vstack((rdf.bins, cn)), protocol=2))
os.system('rm traj.pdb')
os.chdir(dir_molten_salt_system)
return radial_distribution_function_dict, coordination_number_dict
def test_exclusion(sels):
# should see two distances with 4 counts each
s1, s2 = sels
rdf = InterRDF(s1, s2, exclusion_block=(1, 2)).run()
assert rdf.count.sum() == 4
def test_double_run(sels):
# running rdf twice should give the same result
s1, s2 = sels
rdf = InterRDF(s1, s2).run()
rdf.run()
assert len(rdf.count[rdf.count == 4]) == 2
def test_count(sels):
# should see two distances with 4 counts each
s1, s2 = sels
rdf = InterRDF(s1, s2).run()
assert len(rdf.count[rdf.count == 4]) == 2
# =============================================================================
print ("\nThe minimum distance between spheres is %s" %np.min(pos_m))
vol_atom = 4/3 *np.pi*(0.5)**3
ff = atoms.n_atoms* vol_atom / geometry.volume
print ("The old ff is %lf" %ff)
# =============================================================================
# Pair correlation
# =============================================================================
from MDAnalysis.analysis.rdf import InterRDF
rdf = InterRDF(atoms,atoms,exclusion_block = (1,1),range = [0,2.5],verbose = True)
rdf.run()
plt.plot(rdf.bins, rdf.rdf)
plt.savefig("gr.pdf")
plt.show()
# =============================================================================
# Converting to real units
# =============================================================================
diameter = 2*real_radius
positions = convert_into_real(positions,diameter,1)
def test_nbins(u):
s1 = u.atoms[:3]
s2 = u.atoms[3:]
rdf = InterRDF(s1, s2, nbins=412).run()
assert len(rdf.bins) == 412
# Example #2: Write the configuration to a PDB file "
# ========================================================="
#
u.atoms.write("system.pdb")
print("===> The initial configuration has been written to system.pdb ")
#
# ========================================================="
# Example #3: Calculate a radial distribution function "
# ========================================================="
#
from MDAnalysis.analysis.rdf import InterRDF
charged = u.select_atoms("prop charge > 0")
rdf = InterRDF(charged, charged, nbins=7, range=(0, 10))
# This runs so far only over the single frame we have loaded.
# Multiframe averaging must be done by hand
rdf.run()
#
# ========================================================="
# Example #4: Saving frames to a GROMACS's TRR trajectory
# ========================================================="
#
from MDAnalysis.coordinates.TRR import TRRWriter
W = TRRWriter("traj.trr", n_atoms=len(system.part))
def test_count_sum(sels):
# OW vs HW
# should see 8 comparisons in count
s1, s2 = sels
rdf = InterRDF(s1, s2).run()
assert rdf.count.sum() == 8