def test_get_pattern(self):
s = self.get_structure("CsCl")
c = XRDCalculator()
xrd = c.get_pattern(s, two_theta_range=(0, 90))
self.assertTrue(xrd.to_json()) # Test MSONAble property
# Check the first two peaks
self.assertAlmostEqual(xrd.x[0], 21.107738329639844)
self.assertAlmostEqual(xrd.y[0], 36.483184003748946)
self.assertEqual(xrd.hkls[0], [{'hkl': (1, 0, 0), 'multiplicity': 6}])
self.assertAlmostEqual(xrd.d_hkls[0], 4.2089999999999996)
self.assertAlmostEqual(xrd.x[1], 30.024695921112777)
self.assertAlmostEqual(xrd.y[1], 100)
self.assertEqual(xrd.hkls[1], [{"hkl": (1, 1, 0), "multiplicity": 12}])
self.assertAlmostEqual(xrd.d_hkls[1], 2.976212442014178)
s = self.get_structure("LiFePO4")
xrd = c.get_pattern(s, two_theta_range=(0, 90))
self.assertAlmostEqual(xrd.x[1], 17.03504233621785)
self.assertAlmostEqual(xrd.y[1], 50.400928948337075)
s = self.get_structure("Li10GeP2S12")
xrd = c.get_pattern(s, two_theta_range=(0, 90))
self.assertAlmostEqual(xrd.x[1], 14.058274883353876)
self.assertAlmostEqual(xrd.y[1], 4.4111123641667671)
# Test a hexagonal structure.
s = self.get_structure("Graphite")
xrd = c.get_pattern(s, two_theta_range=(0, 90))
self.assertAlmostEqual(xrd.x[0], 26.21057350859598)
self.assertAlmostEqual(xrd.y[0], 100)
self.assertAlmostEqual(len(xrd.hkls[0][0]["hkl"]), 4)
# Add test case with different lengths of coefficients.
# Also test d_hkl.
coords = [[0.25, 0.25, 0.173], [0.75, 0.75, 0.827], [0.75, 0.25, 0],
[0.25, 0.75, 0], [0.25, 0.25, 0.676], [0.75, 0.75, 0.324]]
sp = ["Si", "Si", "Ru", "Ru", "Pr", "Pr"]
s = Structure(Lattice.tetragonal(4.192, 6.88), sp, coords)
xrd = c.get_pattern(s)
self.assertAlmostEqual(xrd.x[0], 12.86727341476735)
self.assertAlmostEqual(xrd.y[0], 31.448239816769796)
self.assertAlmostEqual(xrd.d_hkls[0], 6.88)
self.assertEqual(len(xrd), 42)
xrd = c.get_pattern(s, two_theta_range=[0, 60])
self.assertEqual(len(xrd), 18)
# Test with and without Debye-Waller factor
tungsten = Structure(Lattice.cubic(3.1653), ["W"] * 2,
[[0, 0, 0], [0.5, 0.5, 0.5]])
xrd = c.get_pattern(tungsten, scaled=False)
self.assertAlmostEqual(xrd.x[0], 40.294828554672264)
self.assertAlmostEqual(xrd.y[0], 2414237.5633093244)
self.assertAlmostEqual(xrd.d_hkls[0], 2.2382050944897789)
c = XRDCalculator(debye_waller_factors={"W": 0.1526})
xrd = c.get_pattern(tungsten, scaled=False)
self.assertAlmostEqual(xrd.x[0], 40.294828554672264)
self.assertAlmostEqual(xrd.y[0], 2377745.2296686019)
self.assertAlmostEqual(xrd.d_hkls[0], 2.2382050944897789)
c.get_plot(tungsten).show()
def test_get_xrd_data(self):
a = 4.209
latt = Lattice.cubic(a)
structure = Structure(latt, ["Cs", "Cl"], [[0, 0, 0], [0.5, 0.5, 0.5]])
c = XRDCalculator()
data = c.get_xrd_data(structure, two_theta_range=(0, 90))
#Check the first two peaks
self.assertAlmostEqual(data[0][0], 21.107738329639844)
self.assertAlmostEqual(data[0][1], 36.483184003748946)
self.assertEqual(data[0][2], {(1, 0, 0): 6})
self.assertAlmostEqual(data[0][3], 4.2089999999999996)
self.assertAlmostEqual(data[1][0], 30.024695921112777)
self.assertAlmostEqual(data[1][1], 100)
self.assertEqual(data[1][2], {(1, 1, 0): 12})
self.assertAlmostEqual(data[1][3], 2.976212442014178)
s = read_structure(os.path.join(test_dir, "LiFePO4.cif"))
data = c.get_xrd_data(s, two_theta_range=(0, 90))
self.assertAlmostEqual(data[1][0], 17.03504233621785)
self.assertAlmostEqual(data[1][1], 50.400928948337075)
s = read_structure(os.path.join(test_dir, "Li10GeP2S12.cif"))
data = c.get_xrd_data(s, two_theta_range=(0, 90))
self.assertAlmostEqual(data[1][0], 14.058274883353876)
self.assertAlmostEqual(data[1][1], 4.4111123641667671)
# Test a hexagonal structure.
s = read_structure(os.path.join(test_dir, "Graphite.cif"),
primitive=False)
data = c.get_xrd_data(s, two_theta_range=(0, 90))
self.assertAlmostEqual(data[0][0], 7.929279053132362)
self.assertAlmostEqual(data[0][1], 100)
self.assertAlmostEqual(len(list(data[0][2].keys())[0]), 4)
#Add test case with different lengths of coefficients.
#Also test d_hkl.
coords = [[0.25, 0.25, 0.173], [0.75, 0.75, 0.827], [0.75, 0.25, 0],
[0.25, 0.75, 0], [0.25, 0.25, 0.676], [0.75, 0.75, 0.324]]
sp = ["Si", "Si", "Ru", "Ru", "Pr", "Pr"]
s = Structure(Lattice.tetragonal(4.192, 6.88), sp, coords)
data = c.get_xrd_data(s)
self.assertAlmostEqual(data[0][0], 12.86727341476735)
self.assertAlmostEqual(data[0][1], 31.448239816769796)
self.assertAlmostEqual(data[0][3], 6.88)
self.assertEqual(len(data), 42)
data = c.get_xrd_data(s, two_theta_range=[0, 60])
self.assertEqual(len(data), 18)
#Test with and without Debye-Waller factor
tungsten = Structure(Lattice.cubic(3.1653), ["W"] * 2,
[[0, 0, 0], [0.5, 0.5, 0.5]])
data = c.get_xrd_data(tungsten, scaled=False)
self.assertAlmostEqual(data[0][0], 40.294828554672264)
self.assertAlmostEqual(data[0][1], 2414237.5633093244)
self.assertAlmostEqual(data[0][3], 2.2382050944897789)
c = XRDCalculator(debye_waller_factors={"W": 0.1526})
data = c.get_xrd_data(tungsten, scaled=False)
self.assertAlmostEqual(data[0][0], 40.294828554672264)
self.assertAlmostEqual(data[0][1], 2377745.2296686019)
self.assertAlmostEqual(data[0][3], 2.2382050944897789)
def set_from_pymatgen(self,
structure,
k0,
k0p,
file=None,
name='',
version=4,
comments='',
thermal_expansion=0.,
two_theta_range=(0., 40.)):
"""
set parameters from pymatgen outputs
Parameters
----------
structure = pymatgen structure object
k0 = bulk modulus
k0p = pressure derivative of bulk modulus
file = file name (optional)
name = name (optional)
version = version (optional)
comments = comments (optional)
thermal_expansion = 0 (optional)
Returns
-------
"""
lattice = structure.lattice
self.k0 = k0
self.k0p = k0p
self.a0 = lattice.a
self.b0 = lattice.b
self.c0 = lattice.c
self.alpha0 = lattice.alpha
self.beta0 = lattice.beta
self.gamma0 = lattice.gamma
self.symmetry = SpacegroupAnalyzer(structure).get_crystal_system()
self.file = file
self.name = name
self.version = version
self.comments = comments
self.thermal_expansion = thermal_expansion
self.v0 = cal_UnitCellVolume(self.symmetry, self.a0, self.b0, self.c0,
self.alpha0, self.beta0, self.gamma0)
c = XRDCalculator(wavelength=0.3344)
pattern = c.get_xrd_data(structure, two_theta_range=two_theta_range)
DiffLines = []
for line in pattern:
hkl_key = line[2].keys()
hkl_txt = str(hkl_key)[12:-3].split(",")
d_line = DiffractionLine()
d_line.dsp0 = line[3]
d_line.dsp = line[3]
d_line.intensity = line[1]
d_line.h = int(hkl_txt[0])
d_line.k = int(hkl_txt[1])
d_line.l = int(hkl_txt[-1])
DiffLines.append(d_line)
self.DiffLines = DiffLines
def generate_diffraction_plot(args):
s = Structure.from_file(args.filenames[0])
c = XRDCalculator()
if args.outfile:
c.get_xrd_plot(s).savefig(args.outfile[0])
else:
c.show_xrd_plot(s)
def get_interplanar_spacing(self, structure, surface):
xc = XRDCalculator()
xrd_data = xc.get_xrd_data(structure)
logging.info("xrd_data: {}".format(xrd_data))
sort_data = pd.DataFrame(
xrd_data,
columns=["two_theta", "intensity", "miller_index_dict", "d_hkl"])
matcher = (1, 1, 1)
logging.info("sort_data: {}".format(sort_data))
flag = 0
for mid in sort_data.miller_index_dict:
logging.info("mid: {}".format(mid))
for key, value in mid.items():
key = reduce_vector(key)
if (surface == key):
matcher = mid
flag = 1
break
else:
logging.info("*" * 50)
logging.info("key: {}".format(key))
logging.info("value {}".format(value))
logging.info("*" * 50)
if flag == 1:
break
spacing = sort_data[sort_data.miller_index_dict ==
matcher].d_hkl.values[0]
return spacing
def pattern_from_mpid_or_struct(rad_source, mp_time, struct_time, mpid, struct):
if (struct_time is None) or (mp_time is None):
raise PreventUpdate
if struct_time > mp_time:
if struct is None:
raise PreventUpdate
sga = SpacegroupAnalyzer(self.from_data(struct))
struct = (
sga.get_conventional_standard_structure()
) # always get conventional structure
elif mp_time >= struct_time:
if mpid is None:
raise PreventUpdate
mpid = mpid["mpid"]
with MPRester() as mpr:
struct = mpr.get_structure_by_material_id(
mpid, conventional_unit_cell=True
)
xrdc = XRDCalculator(wavelength=rad_source)
data = xrdc.get_pattern(struct, two_theta_range=None)
return data.as_dict()
def abicomp_xrd(options):
"""
Compare X-ray diffraction plots (requires FILES with structure).
"""
if len(options.paths) < 2:
print("You need more than one structure to compare!")
return 1
structures = [abilab.Structure.from_file(p) for p in options.paths]
dfs = abilab.dataframes_from_structures(
structures, index=[os.path.relpath(p) for p in options.paths])
abilab.print_dataframe(dfs.lattice, title="Lattice parameters:")
if options.verbose:
abilab.print_dataframe(
dfs.coords,
title="Atomic positions (columns give the site index):")
from pymatgen.analysis.diffraction.xrd import XRDCalculator
two_theta_range = tuple(float(t) for t in options.two_theta_range)
xrd = XRDCalculator(wavelength=options.wavelength, symprec=options.symprec)
xrd.plot_structures(structures,
two_theta_range=two_theta_range,
fontsize=6,
annotate_peaks=not options.no_annotate_peaks,
tight_layout=True)
return 0
def from_structure( # type: ignore[override]
cls,
material_id: Union[MPID, int],
spectrum_id: str,
structure: Structure,
wavelength: float,
min_two_theta=0,
max_two_theta=180,
symprec=0.1,
**kwargs,
) -> "XRDDoc":
calc = XRDCalculator(wavelength=wavelength, symprec=symprec)
pattern = calc.get_pattern(
structure, two_theta_range=(min_two_theta, max_two_theta)
)
return super().from_structure(
material_id=material_id,
spectrum_id=spectrum_id,
structure=structure,
spectrum=pattern,
wavelength=wavelength,
min_two_theta=min_two_theta,
max_two_theta=max_two_theta,
**kwargs,
)
def get_xrd_plot(args):
"""
Plot XRD
Args:
args (dict): Args from argparse
"""
s = Structure.from_file(args.xrd_structure_file)
c = XRDCalculator()
return c.get_plot(s)
def get_kinematic_reflection(unit_cell, top=3):
"""
Find top hkl and d_hkl with highest intensity.
"""
xrd = XRDCalculator().get_pattern(unit_cell)
hkls = np.array([itm[0]['hkl'] for itm in xrd.hkls])
intens = xrd.y
if top > intens.size:
top = intens.size
top_ind = np.argsort(intens)[::-1][:top]
hkl_vecs = hkls[top_ind]
d_hkls = np.array(xrd.d_hkls)[top_ind]
return hkl_vecs, d_hkls
def calculate(self, structure, show=False):
c = XRDCalculator(wavelength=self.wavelength)
xrd_pattern = c.get_xrd_pattern(AseAtomsAdaptor.get_structure(structure))
if show:
c.show_xrd_plot(AseAtomsAdaptor.get_structure(structure))
descriptor_data = dict(descriptor_name=self.name, descriptor_info=str(self), xrd_pattern=xrd_pattern)
structure.info['descriptor'] = descriptor_data
return structure
def xrd(pymat_struct,
descriptor_size=300,
two_theta_min=0.0,
two_theta_max=90.0):
"""construct XRD descriptor"""
# get values from XRD
two_theta = np.array(XRDCalculator().get_xrd_pattern(pymat_struct).x)
intensity = np.array(XRDCalculator().get_xrd_pattern(pymat_struct).y)
# create & digitize bins, include the right bourndary only (zeroth bin is designated for zero only)
# bin_size = 90/vector_size
# bins = np.arange(two_theta_min, two_theta_max + bin_size, bin_size)
bins = np.linspace(two_theta_min, two_theta_max, descriptor_size)
index_of_bins_for_points = np.digitize(two_theta, bins, right=True)
# number of points from XRD = len(two_theta) = len(index_of_bins_for_points)
num_points = len(two_theta)
descriptor_vector = np.zeros(len(bins))
# put XRD points into bins
for i in range(num_points):
descriptor_vector[index_of_bins_for_points[i]] += intensity[i]
return descriptor_vector
def xrd(self, ):
import os
os.chdir(r"D:\Desktop\VASP practical\workdir")
from pymatgen import Lattice, Structure
from pymatgen.analysis.diffraction.xrd import XRDCalculator
from IPython.display import Image, display
from pymatgen.ext.matproj import MPRester
mpr = MPRester()
mp_id = self.mp_id
structure = mpr.get_structure_by_material_id(mp_id)
c = XRDCalculator()
print(c)
c.show_plot(structure)
print(os.getcwd())
def get_xrd_from_struct(self, structure):
doc = {}
for xs in self.__settings:
xrdcalc = XRDCalculator(wavelength="".join([xs['target'], xs['edge']]),
symprec=xs.get('symprec', 0))
pattern = jsanitize(xrdcalc.get_xrd_pattern(
structure, two_theta_range=xs['two_theta']).as_dict())
# TODO: Make sure this is what the website actually needs
d = {'wavelength': {'element': xs['target'],
'in_angstroms': WAVELENGTHS["".join([xs['target'], xs['edge']])]},
'pattern': pattern}
doc[xs['target']] = d
return doc
def get_xrd_from_struct(self, structure):
doc = {}
for xs in self.__xrd_settings:
xrdcalc = XRDCalculator(wavelength="".join([xs['target'], xs['edge']]),
symprec=xs.get('symprec', 0))
pattern = [[float(p[1]), [int(x) for x in list(p[2])[0]], p[0], float(p[3])] for p in
xrdcalc.get_xrd_data(structure, two_theta_range=xs['two_theta'])]
# TODO: Make sure this is what the website actually needs
d = {'wavelength': {'element': xs['target'],
'in_angstroms': WAVELENGTHS["".join([xs['target'], xs['edge']])]},
'meta': ['amplitude', 'hkl', 'two_theta', 'd_spacing'],
'pattern': pattern}
doc[xs['target']] = d
return doc
def pattern_from_struct(struct, xrdcalculator_kwargs):
if struct is None:
raise PreventUpdate
struct = self.from_data(struct)
xrdcalculator_kwargs = self.from_data(xrdcalculator_kwargs)
sga = SpacegroupAnalyzer(struct)
struct = (
sga.get_conventional_standard_structure()
) # always get conventional structure
xrdc = XRDCalculator(**xrdcalculator_kwargs)
data = xrdc.get_pattern(struct, two_theta_range=None)
return data.as_dict()
def get_xrd():
struct = readstructure()
xrd = XRDCalculator()
# xrd_data=xrd.get_xrd_pattern(struct)
xrd_data = xrd.get_pattern(struct)
jxrd_data = jsanitize(xrd_data.as_dict())
fname = 'XRD.json'
proc_str = "Saving data to " + fname + " File ..."
procs(proc_str, 1, sp='-->>')
json_store(jxrd_data, fname)
data = np.vstack((xrd_data.x, xrd_data.y)).T
margin = 10.
ds = xrd_data.x[0] - margin
de = xrd_data.x[-1] + margin
tmp_data = [ds] + xrd_data.x.tolist() + [de]
tmp_data1 = np.diff(tmp_data).tolist()
tmp_data2 = np.array([0] + np.cumsum(tmp_data1).tolist())
tmp_data3 = tmp_data2 / tmp_data2[-1]
x_data = np.linspace(ds, de, 10000)
y_data = np.zeros((len(x_data)))
for i in range(1, len(tmp_data3) - 1):
index = int(tmp_data3[i] * 10000)
y_data[index] = xrd_data.y[i - 1]
data = np.vstack((x_data, y_data))
data = (smear(data, sigma=0.1)).T
head_line = "#%(key1)+12s %(key2)+12s" % {
'key1': '2theta',
'key2': 'Intensity'
}
fname = 'XRD.dat'
proc_str = "Saving data to " + fname + " File ..."
procs(proc_str, 2, sp='-->>')
write_col_data(fname, data, head_line)
check_matplotlib()
fname = 'XRD.png'
proc_str = "Saving plot to " + fname + " File ..."
procs(proc_str, 3, sp='-->>')
plt = xrd.get_plot(struct)
plt.savefig(fname, format='png')
def peaks_with_gauss(structure, degree_min=0.0, degree_max=90.0, step=0.05):
spectrum = XRDCalculator().get_pattern(structure)
positions, intensities = spectrum.x, spectrum.y
num_points = int((degree_max - degree_min) / step + 1)
num_positions = [int(position / step + 1) for position in positions]
def peak(num_points, position, intensity, M=31, std=3):
k = np.zeros(num_points)
mn = int(position - (M - 1) / 2)
mx = int(position + (M - 1) / 2 + 1)
diff = mx if mx <= num_points else num_points - mn if mn >= 0 else 0
k[mn if mn >= 0 else 0:mx if mx <= num_points else
num_points] = intensity * gaussian(M, std=std)[:diff]
return k
final_intensity = sum(
[peak(num_points, p, i) for p, i in zip(num_positions, intensities)])
return np.linspace(degree_min, degree_max, num_points), final_intensity
def calculate_xrd(request):
results = {}
xrd = XRDCalculator(symprec=0.01)
for name, f in request.FILES.items():
name, s = get_structure(f)
plt = xrd.get_xrd_plot(s, annotate_peaks=False)
fig = plt.gcf()
fig.set_dpi(100)
fig.set_size_inches(8, 6)
ax = plt.gca()
plt.setp(ax.get_xticklabels(), fontsize=16)
plt.setp(ax.get_yticklabels(), fontsize=16)
ax.xaxis.label.set_size(16)
ax.yaxis.label.set_size(16)
si = StringIO()
plt.savefig(si, format="svg")
results[name] = si.getvalue()
return results
def pattern_from_struct(struct, rad_source):
if struct is None or not rad_source:
raise PreventUpdate
struct = self.from_data(struct)
rad_source = self.reconstruct_kwarg_from_state(
callback_context.inputs, "rad_source")
sga = SpacegroupAnalyzer(struct)
struct = (sga.get_conventional_standard_structure()
) # always get conventional structure
xrdc = XRDCalculator(wavelength=WAVELENGTHS[rad_source],
symprec=0,
debye_waller_factors=None)
data = xrdc.get_pattern(struct, two_theta_range=None)
return data.as_dict()
def __init__(self, two_theta_range=(0, 127), bw_method=0.05,
pattern_length=None, **kwargs):
"""
Initialize the featurizer.
Args:
two_theta_range ([float of length 2]): Tuple for range of
two_thetas to calculate in degrees. Defaults to (0, 90). Set to
None if you want all diffracted beams within the limiting
sphere of radius 2 / wavelength.
bw_method (float): how much to smear the XRD pattern
pattern_length (float): length of final array; defaults to one value
per degree (i.e. two_theta_range + 1)
**kwargs: any other arguments to pass into pymatgen's XRDCalculator,
such as the type of radiation.
"""
self.two_theta_range = two_theta_range
self.bw_method = bw_method
self.pattern_length = pattern_length or two_theta_range[1] - \
two_theta_range[0] + 1
self.xrd_calc = XRDCalculator(**kwargs)
def xrd(self, ):
import os
from pymatgen import Lattice, Structure
from pymatgen.analysis.diffraction.xrd import XRDCalculator
from IPython.display import Image, display
from pymatgen import Structure, Lattice, MPRester, Molecule
ass = self.cif_route
print(ass)
# os.chdir(r"D:\Desktop\VASP practical\Input")
# print (os.getcwd())
# Note that you must provide your own API Key, which can
# be accessed via the Dashboard at materialsproject.org
#mpr = MPRester()#密钥
molecule = Molecule.from_file(ass)
structure = molecule.get_boxed_structure(self.a, self.b, self.c)
print(structure)
os.chdir(r"D:\Desktop\VASP practical\Input")
print(os.getcwd())
c = XRDCalculator()
c.show_plot(structure)
print(os.getcwd())
def xrd(self, ):
import os
from pymatgen import Lattice, Structure
from pymatgen.analysis.diffraction.xrd import XRDCalculator
from IPython.display import Image, display
from pymatgen.io.cif import CifParser
ass = self.cif_route
print(ass)
# os.chdir(r"E:\VASP practical\Input")
# print (os.getcwd())
# Note that you must provide your own API Key, which can
# be accessed via the Dashboard at materialsproject.org
#mpr = MPRester()#密钥
struct = CifParser(ass)
structure = struct.get_structures()[0]
print(structure)
os.chdir(r"E:\VASP practical\Input")
print(os.getcwd())
c = XRDCalculator()
c.show_plot(structure)
print(os.getcwd())
# # 4. Get lattice parameters
# In[9]:
lattice = material.lattice
print('Lattice parameters = ', lattice.a, lattice.b, lattice.c, lattice.alpha,
lattice.beta, lattice.gamma)
crystal_system = SpacegroupAnalyzer(material).get_crystal_system()
print(crystal_system)
# # 5. Get diffraction pattern
# In[10]:
c = XRDCalculator(wavelength=wl_xray)
pattern = c.get_xrd_data(material, two_theta_range=xrange)
# ## 5.1. Extract twotheta, d-sp, int, hkl
# In[11]:
d_lines = []
for values in pattern:
hkl_key = values[2].keys()
hkl_txt = str(hkl_key)[12:-3].split(",")
# print(hkl_txt[0], hkl_txt[1], hkl_txt[-1])
d_lines.append([
values[0], values[3], values[1],
int(hkl_txt[0]),
int(hkl_txt[1]),
from pymatgen import Lattice, Structure
from pymatgen.analysis.diffraction.xrd import XRDCalculator
from IPython.display import Image, display
from matplotlib import pyplot
# Create CsCl structure
a = 4.209 #Angstrom(埃:一个长度单位，用来表示原子尺寸、键长和电磁波波长。)
latt = Lattice.cubic(a)
#latt:点阵一个长度为a的立方体
#species：物质，这里是["Cs", "Cl"]
#坐标：三位数组的列表，表示物质的坐标
structure = Structure(latt, ["Cs", "Cl"], [[0, 0, 0], [0.5, 0.5, 0.5]])
c = XRDCalculator()
#get_plot返回的结果就是一个pyplot类型的图片
image = c.get_plot(structure, two_theta_range=(0, 90), annotate_peaks=True, ax=None, with_labels=True, fontsize=16)
#image.show()
image.savefig("alpha CsCl.jpg")
#display(Image(filename=('./PDF - alpha CsCl.png')))
a = 6.923 #Angstrom
latt = Lattice.cubic(a)
structure = Structure(latt, ["Cs", "Cs", "Cs", "Cs", "Cl", "Cl", "Cl", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0], [0, 0.5, 0.5], [0.5, 0, 0.5],
[0.5, 0.5, 0.5], [0, 0, 0.5], [0, 0.5, 0], [0.5, 0, 0]])
image = c.get_plot(structure, two_theta_range=(0, 90), annotate_peaks=True, ax=None, with_labels=True, fontsize=16)
#display(Image(filename=('./PDF - beta CsCl.png')))这段代码display我还没有弄明白，帮我看看哪里出问题了
def list_get_pattern_xrd(list_struc):
ls = []
for structure in list_struc:
i = XRDCalculator()
ls.append(i.get_pattern(structure))
return ls
def set_from_pymatgen(self, structure, k0, k0p, file=None,
name='', version=4, int_min=0.1,
comments='', thermal_expansion=0.,
two_theta_range=(0., 30.)):
"""
set parameters from pymatgen outputs
Parameters
----------
structure = pymatgen structure object
k0 = bulk modulus
k0p = pressure derivative of bulk modulus
file = file name (optional)
name = name (optional)
version = version (optional)
comments = comments (optional)
thermal_expansion = 0 (optional)
Returns
-------
"""
lattice = structure.lattice
self.k0 = k0
self.k0p = k0p
self.a0 = float(lattice.a)
self.b0 = float(lattice.b)
self.c0 = float(lattice.c)
self.alpha0 = float(lattice.alpha)
self.beta0 = float(lattice.beta)
self.gamma0 = float(lattice.gamma)
self.symmetry = str(SpacegroupAnalyzer(structure).get_crystal_system())
self.file = file
self.name = name
self.version = version
self.comments = comments
self.thermal_expansion = thermal_expansion
self.v0 = cal_UnitCellVolume(self.symmetry,
self.a0, self.b0, self.c0,
self.alpha0, self.beta0,
self.gamma0)
c = XRDCalculator(wavelength=0.3344)
pattern = c.get_pattern(structure, two_theta_range=two_theta_range)
h = []
k = []
l = []
for i in range(pattern.hkls.__len__()):
h.append(pattern.hkls[i][0]['hkl'][0])
k.append(pattern.hkls[i][0]['hkl'][1])
l.append(pattern.hkls[i][0]['hkl'][-1])
d_lines = np.transpose([pattern.x, pattern.d_hkls, pattern.y, h, k, l])
DiffLines = []
for line in d_lines:
if float(line[2]) >= int_min:
d_line = DiffractionLine()
d_line.dsp0 = float(line[1])
#d_line.dsp = float(line[1])
d_line.intensity = float(line[2])
d_line.h = float(line[3])
d_line.k = float(line[4])
d_line.l = float(line[5])
DiffLines.append(d_line)
self.DiffLines = DiffLines
def get_xrd_plot(args):
s = Structure.from_file(args.xrd_structure_file)
c = XRDCalculator()
return c.get_plot(s)
def xrd(structure: Structure,
two_theta_range: Tuple[int, int] = (0, 120),
sigma: float = 0.05,
nsample: int = 5000,
fig_name: str = "XRD.png",
peak_raw_fname: str = "",
plot_dat_fname: str = ""):
'''
Calculate XRD pattern of given structure, raw pattern data is returned
@in
- structure, Structure
- two_theta_range, (int, int), range of 2Theta in XRD pattern
- sigma, float, gaussian smearing width
- nsample, int, how many points in final plot
- fig_name, str, name of the figure file to be written,
default is XRD.png
- peak_raw_fname, str, name of the raw data file containing 2Theta and
intensity.
- plot_dat_fname, str, name of the plot data file. That plot data was
used to plot the XRD pattern.
@out
- x, np.1darray, theta
- y, np.1darray, intensity
- plot_x, np.1darray, theta of final data in plotting
- plot_y, np.1darray, intensity of final data in plotting
'''
def _smearing(x,
y,
sigma=sigma,
nsample=nsample) -> Tuple[NDArray, NDArray]:
'''
Apply smearing to discret delta functions to get a continuous array
@in
- x: x coordinates of peak
- y: peak heights
@out
- res_x
- res_y
'''
def _smearing_helper(x, x0, sigma=sigma):
return np.exp(-(x - x0)**2 / (2 * sigma**2))
assert x.shape == y.shape
npeaks = x.shape[0]
res_x = np.linspace(two_theta_range[0],
two_theta_range[1],
num=nsample)
smear_res = np.empty((npeaks, nsample))
for ipeak in range(npeaks):
smear_res[ipeak] = _smearing_helper(res_x, x[ipeak]) * y[ipeak]
pass
res_y = np.sum(smear_res, axis=(0))
return (res_x, res_y)
c = XRDCalculator()
p = c.get_pattern(structure, two_theta_range=two_theta_range)
(x, y) = _smearing(p.x, p.y, sigma=sigma)
plt.figure()
plt.plot(x, y)
plt.vlines(p.x, ymin=-5, ymax=-1)
plt.ylim(-5, 110)
plt.xlabel(r"$2\theta$ ($^\circ$)")
plt.ylabel(r"Intensities (scaled)")
if "" != fig_name:
plt.savefig(fig_name, dpi=800, linewidth=0.01)
if "" != peak_raw_fname:
with open(peak_raw_fname, 'w') as f:
to_be_written = "# {:^10} {:^12} {:^9}\n".format(
"2Theta", "Intensity", "Miller")
for (_x, _y, hkls) in zip(p.x, p.y, p.hkls):
label = ",".join([str(hkl['hkl']) for hkl in hkls])
to_be_written += " {:11.7f} {:11.7f} {}\n".format(
_x, _y, label)
print(to_be_written, file=f)
if "" != plot_dat_fname:
with open(plot_dat_fname, 'w') as f:
to_be_written = "# {:^10} {:^12}\n".format("2Theta", "Intensity")
for (_x, _y) in np.vstack([x, y]).T:
to_be_written += " {:11.7f} {:11.7f}\n".format(_x, _y)
print(to_be_written, file=f)
return (p.x, p.y, x, y)
dest_dir = str(sys.argv[2])
#wave = str(sys.argv[2])
# wave = One of [Cuka, AgKa, MoKa, FeKa]
p = Poscar.from_file(os.path.join(poscar_dir, "POSCAR"),
check_for_POTCAR=False)
lattice = p.structure.lattice
species = p.structure.species
frac_coords = p.structure.frac_coords
structure = Structure(lattice, species, frac_coords)
plt = pretty_plot(16, 14)
ax = plt.gca()
c_cuka = XRDCalculator("CuKa")
d1 = c_cuka.get_xrd_plot(structure,
two_theta_range=(0, 100),
annotate_peaks=False,
ax=ax)
d1.savefig(os.path.join(dest_dir, "xrd_CuKa.png"))
c_agka = XRDCalculator("AgKa")
d2 = c_agka.get_xrd_plot(structure,
two_theta_range=(0, 100),
annotate_peaks=False,
ax=ax)
d2.savefig(os.path.join(dest_dir, "xrd_AgKa.png"))
c_moka = XRDCalculator("MoKa")
d3 = c_moka.get_xrd_plot(structure,
