def export(self, filename):
"""
Export the crystalline structure on file filename.
Returns:
Instance of :class:`Visualizer`
The format is defined by the extension in filename:
See :class:`Visualizer` for the list of applications and formats supported.
#. "prefix.xsf" for XcrysDen files.
An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
"""
if "." not in filename:
raise ValueError("Cannot detect extension in filename %s: " % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]:
# filename == ".ext" ==> Create temporary file.
import tempfile
filename = tempfile.mkstemp(suffix="."+ext, text=True)[1]
with open(filename, mode="w") as fh:
if ext == "xsf": # xcrysden
xsf.xsf_write_structure(fh, structures=[self])
else:
raise Visualizer.Error("extension %s is not supported." % ext)
return Visualizer.from_file(filename)
def export_ur2(self, filename, structure):
"""
Export the wavefunction on file filename.
Format is defined by the extension in filename.
"""
if "." not in filename:
raise ValueError("Cannot detect file extension in: %s" % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]: # fname == ".ext" ==> Create temporary file.
filename = tempfile.mkstemp(suffix="." + ext, text=True)[1]
print("Creating temporary file: %s" % filename)
# Compute |u(r)|2 and write data according to ext.
ur2 = np.reshape(self.ur2, (1,) + self.ur2.shape)
with open(filename, mode="w") as fh:
if ext == "xsf":
# xcrysden
xsf_write_structure(fh, structures=[structure])
xsf_write_data(fh, structure, ur2, add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." % ext)
return Visualizer.from_file(filename)
def export(self, filename):
"""
Export the real space data on file filename.
Format is defined by the extension in filename.
See :class:`Visualizer` for the list of applications and formats supported.
"""
if "." not in filename:
raise ValueError(" Cannot detect file extension in filename: %s " % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]: # filename == ".ext" ==> Create temporary file.
import tempfile
filename = tempfile.mkstemp(suffix="."+ext, text=True)[1]
with open(filename, mode="w") as fh:
if ext == "xsf":
# xcrysden
xsf.xsf_write_structure(fh, self.structure)
xsf.xsf_write_data(fh, self.structure, self.datar, add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." % ext)
return Visualizer.from_file(filename)
def export(self, filename, visu=None):
"""
Export the crystalline structure on file filename.
Args:
filename: String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format. An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
visu: `Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of applications and formats supported.
Returns: Instance of :class:`Visualizer`
"""
print("Warning: work in progress")
raise NotImplementedError("typat is missing in HIST --> wrong structures")
if "." not in filename:
raise ValueError("Cannot detect extension in filename %s: " % filename)
#import tempfile
#_, tmpfile = tempfile.mkstemp(suffix='', prefix='.xsf', text=True)
from abipy.iotools.xsf import xsf_write_structure
with open(filename, "w") as fh:
xsf_write_structure(fh, self.structures)
def xsf_write(filename, datar):
with open(filename, mode="wt") as fh:
xsf.xsf_write_structure(fh, self.structure)
xsf.xsf_write_data(fh,
self.structure,
datar,
add_replicas=True)
def visualize_qpoint_nu(self, qpoint, nu, spin=0, appname="vesta"):
iq, qpoint = self._find_iqpt_qpoint(qpoint)
# Fortran array nctkarr_t("v1_qnu", "dp", "two, nfft, nspden, natom3, nqlist")])
v1_qnu = self.reader.read_variable("v1_qnu")[iq, nu, spin]
v1_qnu = v1_qnu[:, 0] + 1j * v1_qnu[:, 1]
#wqnu = self.reader.read_variable["phfreqs"][nu]
#v1_qnu /= np.sqrt(2 * wqnu)
datar = np.reshape(np.abs(v1_qnu), self.ngfft)
visu = Visualizer.from_name(appname)
ext = "xsf"
if ext not in visu.supported_extensions():
raise ValueError("Visualizer %s does not support XSF files" % visu)
from abipy.core.globals import abinb_mkstemp
_, filename = abinb_mkstemp(suffix="." + ext, text=True)
with open(filename, mode="wt") as fh:
if ext == "xsf":
xsf.xsf_write_structure(fh, self.structure)
xsf.xsf_write_data(fh, self.structure, datar, add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." % ext)
return visu(filename)
def export(self, filename, visu=None, verbose=1):
"""
Export the real space data to file filename.
Args:
filename: String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format (xcrysden_).
An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
visu:
:class:`Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of
applications and formats supported.
verbose: Verbosity level
Returns:
Instance of :class:`Visualizer`
"""
if "." not in filename:
raise ValueError("Cannot detect file extension in filename: %s " % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if verbose:
print("tokens", tokens, "ext", ext)
if not tokens[0]:
# filename == ".ext" ==> Create temporary file.
# dir = os.getcwd() is needed when we invoke the method from a notebook.
# nbworkdir in cwd is needed when we invoke the method from a notebook.
from abipy.core.globals import abinb_mkstemp
_, filename = abinb_mkstemp(suffix="." + ext, text=True)
with open(filename, mode="wt") as fh:
if ext == "xsf":
# xcrysden
xsf.xsf_write_structure(fh, self.structure)
xsf.xsf_write_data(fh, self.structure, self.datar, add_replicas=True)
#elif ext == "POSCAR":
else:
raise NotImplementedError("extension %s is not supported." % ext)
if visu is None:
return Visualizer.from_file(filename)
else:
return visu(filename)
def export_ur2(self, filename, visu=None):
"""
Export :math:`|u(r)|^2` to file ``filename``.
Args:
filename: String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format. An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
visu: :class:`Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of
applications and formats supported.
Returns:
Instance of :class:`Visualizer`
"""
if "." not in filename:
raise ValueError("Cannot detect file extension in: %s" % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]:
# fname == ".ext" ==> Create temporary file.
# dir = os.getcwd() is needed when we invoke the method from a notebook.
from abipy.core.globals import abinb_mkstemp
_, filename = abinb_mkstemp(suffix="." + ext, text=True)
print("Creating temporary file: %s" % filename)
# Compute |u(r)|2 and write data according to ext.
ur2 = np.reshape(self.ur2, (1, ) + self.ur2.shape)
with open(filename, mode="wt") as fh:
if ext == "xsf":
# xcrysden
xsf_write_structure(fh, structures=self.structure)
xsf_write_data(fh, self.structure, ur2, add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." %
ext)
if visu is None:
return Visualizer.from_file(filename)
else:
return visu(filename)
def export_ur2(self, filename, structure, visu=None):
"""
Export u(r)**2 on file filename.
Args:
filename:
String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format. An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
structure:
Structure object.
visu:
`Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of
applications and formats supported.
Returns:
Instance of :class:`Visualizer`
"""
if "." not in filename:
raise ValueError("Cannot detect file extension in: %s" % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]: # fname == ".ext" ==> Create temporary file.
filename = tempfile.mkstemp(suffix="." + ext, text=True)[1]
print("Creating temporary file: %s" % filename)
# Compute |u(r)|2 and write data according to ext.
ur2 = np.reshape(self.ur2, (1,) + self.ur2.shape)
with open(filename, mode="w") as fh:
if ext == "xsf":
# xcrysden
xsf_write_structure(fh, structures=[structure])
xsf_write_data(fh, structure, ur2, add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." % ext)
if visu is None:
return Visualizer.from_file(filename)
else:
return visu(filename)
def export(self, filename, visu=None):
"""
Export the real space data on file filename.
Args:
filename: String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format. An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
visu:
:class:`Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of
applications and formats supported.
Returns:
Instance of :class:`Visualizer`
"""
if "." not in filename:
raise ValueError(" Cannot detect file extension in filename: %s " %
filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]: # filename == ".ext" ==> Create temporary file.
import tempfile
filename = tempfile.mkstemp(suffix="." + ext, text=True)[1]
with open(filename, mode="w") as fh:
if ext == "xsf":
# xcrysden
xsf.xsf_write_structure(fh, self.structure)
xsf.xsf_write_data(fh,
self.structure,
self.datar,
add_replicas=True)
else:
raise NotImplementedError("extension %s is not supported." %
ext)
if visu is None:
return Visualizer.from_file(filename)
else:
return visu(filename)
def export(self, filename, visu=None):
"""
Export the crystalline structure on file filename.
Args:
filename:
String specifying the file path and the file format.
The format is defined by the file extension. filename="prefix.xsf", for example,
will produce a file in XSF format. An *empty* prefix, e.g. ".xsf" makes the code use a temporary file.
visu:
`Visualizer` subclass. By default, this method returns the first available
visualizer that supports the given file format. If visu is not None, an
instance of visu is returned. See :class:`Visualizer` for the list of
applications and formats supported.
Returns:
Instance of :class:`Visualizer`
"""
if "." not in filename:
raise ValueError("Cannot detect extension in filename %s: " % filename)
tokens = filename.strip().split(".")
ext = tokens[-1]
if not tokens[0]:
# filename == ".ext" ==> Create temporary file.
import tempfile
filename = tempfile.mkstemp(suffix="." + ext, text=True)[1]
with open(filename, mode="w") as fh:
if ext == "xsf":
# xcrysden
xsf.xsf_write_structure(fh, structures=[self])
else:
raise Visualizer.Error("extension %s is not supported." % ext)
if visu is None:
return Visualizer.from_file(filename)
else:
return visu(filename)
def main():
def show_examples_and_exit(err_msg=None, error_code=1):
"""Display the usage of the script."""
sys.stderr.write(get_epilog())
if err_msg: sys.stderr.write("Fatal Error\n" + err_msg + "\n")
sys.exit(error_code)
parser = get_parser(with_epilog=True)
# Parse command line.
try:
options = parser.parse_args()
except Exception as exc:
show_examples_and_exit(error_code=1)
if not options.command:
show_examples_and_exit(error_code=1)
# loglevel is bound to the string value obtained from the command line argument.
# Convert to upper case to allow the user to specify --loglevel=DEBUG or --loglevel=debug
import logging
numeric_level = getattr(logging, options.loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % options.loglevel)
logging.basicConfig(level=numeric_level)
if options.verbose > 2:
print(options)
if options.command == "spglib":
structure = abilab.Structure.from_file(options.filepath)
print(
structure.spget_summary(symprec=options.symprec,
angle_tolerance=options.angle_tolerance,
verbose=options.verbose))
#remove_equivalent_atoms(structure)
elif options.command == "abispg":
structure = abilab.Structure.from_file(options.filepath)
spgrp = structure.abi_spacegroup
if spgrp is not None:
print(structure.spget_summary(verbose=options.verbose))
else:
# Here we compare Abinit wrt spglib. If spgrp is None, we create a temporary
# task to run the code in dry-run mode.
print("FILE does not contain Abinit symmetry operations.")
print(
"Calling Abinit in --dry-run mode with chkprim = 0 to get space group."
)
from abipy.data.hgh_pseudos import HGH_TABLE
gsinp = factories.gs_input(structure,
HGH_TABLE,
spin_mode="unpolarized")
gsinp["chkprim"] = 0
abistructure = gsinp.abiget_spacegroup(tolsym=options.tolsym)
print(abistructure.spget_summary(verbose=options.verbose))
diff_structures(
[structure, abistructure],
mode=options.diff_mode,
headers=["Input structure", "After Abinit symmetrization"],
fmt="abivars")
# Save file.
save_structure(abistructure, options)
elif options.command == "convert":
fmt = options.format
if fmt == "cif" and options.filepath.endswith(".cif"): fmt = "abivars"
print(abilab.Structure.from_file(options.filepath).convert(fmt=fmt))
elif options.command == "supercell":
structure = abilab.Structure.from_file(options.filepath)
options.scaling_matrix = np.array(options.scaling_matrix)
if len(options.scaling_matrix) == 9:
options.scaling_matrix.shape = (3, 3)
if options.verbose:
print("scaling matrix: ", options.scaling_matrix)
supcell = structure * options.scaling_matrix
#supcell = structure.make_supercell(scaling_matrix, to_unit_cell=True)
print(supcell.convert(fmt=options.format))
elif options.command == "abisanitize":
print("\nCalling abi_sanitize to get a new structure in which:")
print(" * Structure is refined.")
print(" * Reduced to primitive settings.")
print(
" * Lattice vectors are exchanged if the triple product is negative\n"
)
structure = abilab.Structure.from_file(options.filepath)
sanitized = structure.abi_sanitize(
symprec=options.symprec,
angle_tolerance=options.angle_tolerance,
primitive=not options.no_primitive,
primitive_standard=options.primitive_standard)
index = [options.filepath, "abisanitized"]
dfs = abilab.dataframes_from_structures([structure, sanitized],
index=index,
with_spglib=True)
abilab.print_dataframe(dfs.lattice, title="Lattice parameters:")
abilab.print_dataframe(
dfs.coords,
title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
#print(sanitized.convert(fmt="cif"))
else:
#print("\nDifference between structures:")
if len(structure) == len(sanitized):
table = []
for line1, line2 in zip(
str(structure).splitlines(),
str(sanitized).splitlines()):
table.append([line1, line2])
print(
str(
tabulate(table,
headers=["Initial structure",
"Abisanitized"])))
else:
print("\nInitial structure:")
print(structure)
print("\nabisanitized structure:")
print(sanitized)
# Save file.
save_structure(sanitized, options)
elif options.command == "irefine":
structure = abilab.Structure.from_file(options.filepath)
sanitized = structure.copy()
symprec, angle_tolerance = options.symprec, options.angle_tolerance
print(
"Calling abi_sanitize with increasing tolerances to reach target space group:",
options.target_spgnum)
print("Using symprec_step: ", options.symprec_step,
", angle_tolerance_step:", options.angle_tolerance_step,
"ntrial", options.ntrial)
itrial = 0
while itrial < options.ntrial:
print(">>> Trying with symprec: %s, angle_tolerance: %s" %
(symprec, angle_tolerance))
sanitized = sanitized.abi_sanitize(
symprec=symprec,
angle_tolerance=angle_tolerance,
primitive=not options.no_primitive,
primitive_standard=options.primitive_standard)
spg_symb, spg_num = sanitized.get_space_group_info(
symprec=symprec, angle_tolerance=angle_tolerance)
print(">>> Space-group number:", spg_symb, ", symbol:", spg_num,
"for trial:", itrial)
if spg_num == options.target_spgnum:
print(2 * "\n", "# Final structure with space group number:",
spg_symb, ", symbol:", spg_num, 2 * "\n")
print(sanitized.convert(fmt="cif"))
break
# Increment counter and tols.
itrial += 1
symprec += options.symprec_step
angle_tolerance += options.angle_tolerance_step
else:
print("Cannot find space group number:", options.target_spgnum,
"after", options.ntrial, "iterations")
return 1
# Save file.
#save_structure(sanitized, options)
elif options.command == "conventional":
print(
"\nCalling get_conventional_standard_structure to get conventional structure:"
)
print(
"The standards are defined in Setyawan, W., & Curtarolo, S. (2010). "
)
print(
"High-throughput electronic band structure calculations: Challenges and tools. "
)
print(
"Computational Materials Science, 49(2), 299-312. doi:10.1016/j.commatsci.2010.05.010\n"
)
structure = abilab.Structure.from_file(options.filepath)
conv = structure.get_conventional_standard_structure(
international_monoclinic=True,
symprec=options.symprec,
angle_tolerance=options.angle_tolerance)
index = [options.filepath, "conventional"]
dfs = abilab.dataframes_from_structures([structure, conv],
index=index,
with_spglib=True)
abilab.print_dataframe(dfs.lattice, title="Lattice parameters:")
if options.verbose:
abilab.print_dataframe(
dfs.coords,
title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
else:
#print("\nDifference between structures:")
if len(structure) == len(conv):
table = []
for line1, line2 in zip(
str(structure).splitlines(),
str(conv).splitlines()):
table.append([line1, line2])
print(
str(
tabulate(table,
headers=["Initial structure",
"Conventional"])))
else:
print("\nInitial structure:\n", structure)
print("\nConventional structure:\n", conv)
# Save file.
save_structure(conv, options)
elif options.command == "neighbors":
abilab.Structure.from_file(
options.filepath).print_neighbors(radius=options.radius)
elif options.command == "interpolate":
initial_structure = abilab.Structure.from_file(options.filepaths[0])
end_structure = abilab.Structure.from_file(options.filepaths[1])
structures = initial_structure.interpolate(
end_structure,
nimages=options.nimages,
interpolate_lattices=False,
pbc=True,
autosort_tol=options.autosort_tol)
structures = list(map(abilab.Structure.as_structure, structures))
for i, s in enumerate(structures):
print(marquee("Structure #%d" % i, mark="="))
print(s.convert(fmt=options.format))
print(" ")
elif options.command == "xrd":
structure = abilab.Structure.from_file(options.filepath)
two_theta_range = tuple(float(t) for t in options.two_theta_range)
structure.plot_xrd(wavelength=options.wavelength,
two_theta_range=two_theta_range,
symprec=options.symprec,
annotate_peaks=not options.no_annotate_peaks)
elif options.command == "oxistate":
print(
abilab.Structure.from_file(
options.filepath).get_oxi_state_decorated())
elif options.command == "ipython":
structure = abilab.Structure.from_file(options.filepath)
print(
"Invoking Ipython, `structure` object will be available in the Ipython terminal"
)
import IPython
IPython.start_ipython(argv=[], user_ns={"structure": structure})
elif options.command == "notebook":
structure = abilab.Structure.from_file(options.filepath)
structure.make_and_open_notebook(nbpath=None,
foreground=options.foreground)
elif options.command == "visualize":
structure = abilab.Structure.from_file(options.filepath)
print(structure)
print("Visualizing structure with:", options.appname)
structure.visualize(appname=options.appname)
elif options.command == "kpath":
structure = abilab.Structure.from_file(options.filepath)
print("# Abinit Structure")
print(structure.abi_string)
print("\n# K-path in reduced coordinates:")
print("# tolwfr 1e-20 iscf -2 getden ??")
print(" ndivsm 10")
print(" kptopt", -(len(structure.hsym_kpoints) - 1))
print(" kptbounds")
for k in structure.hsym_kpoints:
print(" %+.5f %+.5f %+.5f" % tuple(k.frac_coords), "#",
k.name)
elif options.command == "bz":
abilab.Structure.from_file(options.filepath).plot_bz()
elif options.command == "ngkpt":
d = abilab.Structure.from_file(options.filepath).calc_ksampling(
options.nksmall)
print("ngkpt %d %d %d" % (d.ngkpt[0], d.ngkpt[1], d.ngkpt[2]))
print("nshiftk ", len(d.shiftk), "\nshiftk")
for s in d.shiftk:
print(" %s %s %s" % (s[0], s[1], s[2]))
elif options.command == "ktables":
structure = abilab.Structure.from_file(options.filepath)
k = Ktables(structure, options.mesh, options.is_shift,
not options.no_time_reversal)
print(k)
print("")
print(
"NB: These results are obtained by calling spglib with the structure read from file."
)
print(
"The k-points might differ from the ones expected by Abinit, especially if the space groups differ."
)
if not options.verbose:
print("\nUse -v to obtain the BZ --> IBZ mapping.")
else:
print()
k.print_bz2ibz()
elif options.command == "abikmesh":
structure = abilab.Structure.from_file(options.filepath)
from abipy.data.hgh_pseudos import HGH_TABLE
gsinp = factories.gs_input(structure,
HGH_TABLE,
spin_mode="unpolarized",
kppa=options.kppa)
if options.kppa is not None:
print("Calling Abinit to compute the IBZ with kppa:", options.kppa,
"and shiftk:", options.shiftk)
options.ngkpt = None
else:
print("Calling Abinit to compute the IBZ with ngkpt:",
options.ngkpt, "and shiftk", options.shiftk)
ibz = gsinp.abiget_ibz(ngkpt=options.ngkpt,
shiftk=options.shiftk,
kptopt=options.kptopt)
if options.verbose:
print(gsinp)
print("Found %d points in the IBZ:" % len(ibz.points))
for i, (k, w) in enumerate(zip(ibz.points, ibz.weights)):
print("%6d) [%+.3f, %+.3f, %+.3f] weight=%.3f" %
(i, k[0], k[1], k[2], w))
#elif options.command == "kmesh_jhu":
# structure = abilab.Structure.from_file(options.filepath)
# ksampling = structure.ksampling_from_jhudb(kppra=1000)
# #print(ksampling)
elif options.command == "lgk":
structure = abilab.Structure.from_file(options.filepath)
spgrp = structure.abi_spacegroup
if spgrp is None:
cprint("Your file does not contain Abinit symmetry operations.",
"yellow")
cprint(
"Will call spglib to obtain the space group (assuming time-reversal: %s)"
% (not options.no_time_reversal), "yellow")
spgrp = AbinitSpaceGroup.from_structure(
structure,
has_timerev=not options.no_time_reversal,
symprec=options.symprec,
angle_tolerance=options.angle_tolerance)
print()
print(marquee("Structure", mark="="))
print(structure.spget_summary(verbose=options.verbose))
print("\n")
print(marquee("Little Group", mark="="))
ltk = spgrp.find_little_group(kpoint=options.kpoint)
print(ltk.to_string(verbose=options.verbose))
elif options.command == "kstar":
structure = abilab.Structure.from_file(options.filepath)
# TODO
#kstar = structure.get_star_kpoint(options.kpoint, has_timerev=not options.no_time_reversal)
# Call spglib to get spacegroup if Abinit spacegroup is not available.
if structure.abi_spacegroup is None:
structure.spgset_abi_spacegroup(
has_timerev=not options.no_time_reversal)
kpoint = Kpoint(options.kpoint, structure.reciprocal_lattice)
kstar = kpoint.compute_star(structure.abi_spacegroup, wrap_tows=True)
print("Found %s points in the star of %s\n" %
(len(kstar), repr(kpoint)))
for k in kstar:
print(4 * " ", repr(k))
elif options.command == "mp_id":
# Get the Structure corresponding to material_id.
structure = abilab.Structure.from_mpid(options.mpid,
final=True,
api_key=options.mapi_key,
endpoint=options.endpoint)
# Convert to format and print it.
print(structure.convert(fmt=options.format))
elif options.command == "mp_match":
mp = abilab.mp_match_structure(options.filepath)
if not mp.structures:
cprint("No structure found in database", "yellow")
return 1
if options.notebook:
return mp.make_and_open_notebook(foreground=options.foreground)
else:
mp.print_results(fmt=options.format, verbose=options.verbose)
if options.browser:
mp.open_browser(limit=None if options.verbose == 2 else 10)
elif options.command == "mp_search":
mp = abilab.mp_search(options.chemsys_formula_id)
if not mp.structures:
cprint("No structure found in Materials Project database",
"yellow")
return 1
if options.select_spgnum:
mp = mp.filter_by_spgnum(options.select_spgnum)
if options.notebook:
return mp.make_and_open_notebook(foreground=options.foreground)
else:
mp.print_results(fmt=options.format, verbose=options.verbose)
if options.browser:
mp.open_browser(limit=None if options.verbose == 2 else 10)
elif options.command == "mp_pd":
if os.path.exists(options.file_or_elements):
structure = abilab.Structure.from_file(options.file_or_elements)
elements = structure.symbol_set
else:
elements = options.file_or_elements.split("-")
if options.verbose > 1:
print("Building phase-diagram for elements:", elements)
with abilab.restapi.get_mprester(api_key=options.mapi_key,
endpoint=options.endpoint) as rest:
pdr = rest.get_phasediagram_results(elements)
pdr.print_dataframes(verbose=options.verbose)
pdr.plot(show_unstable=options.show_unstable)
elif options.command == "cod_search":
cod = abilab.cod_search(options.formula, primitive=options.primitive)
if not cod.structures:
cprint("No structure found in COD database", "yellow")
return 1
if options.select_spgnum:
cod = cod.filter_by_spgnum(options.select_spgnum)
if options.notebook:
return cod.make_and_open_notebook(foreground=options.foreground)
else:
cod.print_results(fmt=options.format, verbose=options.verbose)
elif options.command == "cod_id":
# Get the Structure from COD
structure = abilab.Structure.from_cod_id(options.cod_identifier,
primitive=options.primitive)
# Convert to format and print it.
print(structure.convert(fmt=options.format))
elif options.command == "animate":
filepath = options.filepath
if any(filepath.endswith(ext) for ext in ("HIST", "HIST.nc")):
with abilab.abiopen(filepath) as hist:
structures = hist.structures
elif "XDATCAR" in filepath:
structures = Xdatcar(filepath).structures
if not structures:
raise RuntimeError(
"Your Xdatcar contains only one structure. Due to a bug "
"in the pymatgen routine, your structures won't be parsed correctly"
"Solution: Add another structure at the end of the file.")
else:
raise ValueError("Don't know how to handle file %s" % filepath)
xsf_write_structure(sys.stdout, structures)
else:
raise ValueError("Unsupported command: %s" % options.command)
return 0
def main():
def show_examples_and_exit(err_msg=None, error_code=1):
"""Display the usage of the script."""
sys.stderr.write(get_epilog())
if err_msg: sys.stderr.write("Fatal Error\n" + err_msg + "\n")
sys.exit(error_code)
parser = get_parser(with_epilog=True)
# Parse command line.
try:
options = parser.parse_args()
except Exception as exc:
show_examples_and_exit(error_code=1)
if not options.command:
show_examples_and_exit(error_code=1)
# loglevel is bound to the string value obtained from the command line argument.
# Convert to upper case to allow the user to specify --loglevel=DEBUG or --loglevel=debug
import logging
numeric_level = getattr(logging, options.loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % options.loglevel)
logging.basicConfig(level=numeric_level)
if options.verbose > 2:
print(options)
if options.command == "spglib":
structure = abilab.Structure.from_file(options.filepath)
print(structure.spget_summary(symprec=options.symprec, angle_tolerance=options.angle_tolerance,
verbose=options.verbose))
#remove_equivalent_atoms(structure)
elif options.command == "abispg":
structure = abilab.Structure.from_file(options.filepath)
check_ordered_structure(structure)
spgrp = structure.abi_spacegroup
if spgrp is not None:
print(structure.spget_summary(verbose=options.verbose))
else:
# Here we compare Abinit wrt spglib. If spgrp is None, we create a temporary
# task to run the code in dry-run mode.
print("FILE does not contain Abinit symmetry operations.")
print("Calling Abinit in --dry-run mode with chkprim = 0 to get space group.")
from abipy.data.hgh_pseudos import HGH_TABLE
gsinp = factories.gs_input(structure, HGH_TABLE, spin_mode="unpolarized")
gsinp["chkprim"] = 0
abistructure = gsinp.abiget_spacegroup(tolsym=options.tolsym)
print(abistructure.spget_summary(verbose=options.verbose))
diff_structures([structure, abistructure], mode=options.diff_mode,
headers=["Input structure", "After Abinit symmetrization"], fmt="abivars")
# Save file.
save_structure(abistructure, options)
elif options.command == "convert":
fmt = options.format
if fmt == "cif" and options.filepath.endswith(".cif"): fmt = "abivars"
print(abilab.Structure.from_file(options.filepath).convert(fmt=fmt))
elif options.command == "supercell":
structure = abilab.Structure.from_file(options.filepath)
options.scaling_matrix = np.array(options.scaling_matrix)
if len(options.scaling_matrix) == 9:
options.scaling_matrix.shape = (3, 3)
if options.verbose:
print("scaling matrix: ", options.scaling_matrix)
supcell = structure * options.scaling_matrix
#supcell = structure.make_supercell(scaling_matrix, to_unit_cell=True)
print(supcell.convert(fmt=options.format))
elif options.command == "abisanitize":
print("\nCalling abi_sanitize to get a new structure in which:")
print(" * Structure is refined.")
print(" * Reduced to primitive settings.")
print(" * Lattice vectors are exchanged if the triple product is negative\n")
structure = abilab.Structure.from_file(options.filepath)
sanitized = structure.abi_sanitize(symprec=options.symprec, angle_tolerance=options.angle_tolerance,
primitive=not options.no_primitive, primitive_standard=options.primitive_standard)
index = [options.filepath, "abisanitized"]
dfs = abilab.dataframes_from_structures([structure, sanitized], index=index, with_spglib=True)
abilab.print_dataframe(dfs.lattice, title="Lattice parameters:")
abilab.print_dataframe(dfs.coords, title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
#print(sanitized.convert(fmt="cif"))
else:
#print("\nDifference between structures:")
if len(structure) == len(sanitized):
table = []
for line1, line2 in zip(str(structure).splitlines(), str(sanitized).splitlines()):
table.append([line1, line2])
print(str(tabulate(table, headers=["Initial structure", "Abisanitized"])))
else:
print("\nInitial structure:")
print(structure)
print("\nabisanitized structure:")
print(sanitized)
# Save file.
save_structure(sanitized, options)
elif options.command == "irefine":
structure = abilab.Structure.from_file(options.filepath)
sanitized = structure.copy()
symprec, angle_tolerance = options.symprec, options.angle_tolerance
print("Calling abi_sanitize with increasing tolerances to reach target space group:", options.target_spgnum)
print("Using symprec_step: ", options.symprec_step, ", angle_tolerance_step:", options.angle_tolerance_step,
"ntrial", options.ntrial)
itrial = 0
while itrial < options.ntrial:
print(">>> Trying with symprec: %s, angle_tolerance: %s" % (symprec, angle_tolerance))
sanitized = sanitized.abi_sanitize(symprec=symprec, angle_tolerance=angle_tolerance,
primitive=not options.no_primitive, primitive_standard=options.primitive_standard)
spg_symb, spg_num = sanitized.get_space_group_info(symprec=symprec, angle_tolerance=angle_tolerance)
print(">>> Space-group number:", spg_symb, ", symbol:", spg_num, "for trial:", itrial)
if spg_num == options.target_spgnum:
print(2 * "\n", "# Final structure with space group number:", spg_symb, ", symbol:", spg_num, 2 *"\n")
print(sanitized.convert(fmt="cif"))
break
# Increment counter and tols.
itrial += 1
symprec += options.symprec_step
angle_tolerance += options.angle_tolerance_step
else:
print("Cannot find space group number:", options.target_spgnum, "after", options.ntrial, "iterations")
return 1
# Save file.
#save_structure(sanitized, options)
elif options.command == "conventional":
print("\nCalling get_conventional_standard_structure to get conventional structure:")
print("The standards are defined in Setyawan, W., & Curtarolo, S. (2010). ")
print("High-throughput electronic band structure calculations: Challenges and tools. ")
print("Computational Materials Science, 49(2), 299-312. doi:10.1016/j.commatsci.2010.05.010\n")
structure = abilab.Structure.from_file(options.filepath)
conv = structure.get_conventional_standard_structure(international_monoclinic=True,
symprec=options.symprec, angle_tolerance=options.angle_tolerance)
index = [options.filepath, "conventional"]
dfs = abilab.dataframes_from_structures([structure, conv], index=index, with_spglib=True)
abilab.print_dataframe(dfs.lattice, title="Lattice parameters:")
if options.verbose:
abilab.print_dataframe(dfs.coords, title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
else:
#print("\nDifference between structures:")
if len(structure) == len(conv):
table = []
for line1, line2 in zip(str(structure).splitlines(), str(conv).splitlines()):
table.append([line1, line2])
print(str(tabulate(table, headers=["Initial structure", "Conventional"])))
else:
print("\nInitial structure:\n", structure)
print("\nConventional structure:\n", conv)
# Save file.
save_structure(conv, options)
elif options.command == "neighbors":
abilab.Structure.from_file(options.filepath).print_neighbors(radius=options.radius)
elif options.command == "interpolate":
initial_structure = abilab.Structure.from_file(options.filepaths[0])
end_structure = abilab.Structure.from_file(options.filepaths[1])
structures = initial_structure.interpolate(end_structure, nimages=options.nimages,
interpolate_lattices=False, pbc=True,
autosort_tol=options.autosort_tol)
structures = list(map(abilab.Structure.as_structure, structures))
for i, s in enumerate(structures):
print(marquee("Structure #%d" % i, mark="="))
print(s.convert(fmt=options.format))
print(" ")
elif options.command == "xrd":
structure = abilab.Structure.from_file(options.filepath)
two_theta_range = tuple(float(t) for t in options.two_theta_range)
structure.plot_xrd(wavelength=options.wavelength, two_theta_range=two_theta_range,
symprec=options.symprec, annotate_peaks=not options.no_annotate_peaks)
elif options.command == "oxistate":
print(abilab.Structure.from_file(options.filepath).get_oxi_state_decorated())
elif options.command == "ipython":
structure = abilab.Structure.from_file(options.filepath)
print("Invoking Ipython, `structure` object will be available in the Ipython terminal")
import IPython
IPython.start_ipython(argv=[], user_ns={"structure": structure})
elif options.command == "notebook":
structure = abilab.Structure.from_file(options.filepath)
structure.make_and_open_notebook(nbpath=None, foreground=options.foreground)
elif options.command == "visualize":
structure = abilab.Structure.from_file(options.filepath)
print(structure)
print("Visualizing structure with:", options.appname)
structure.visualize(appname=options.appname)
elif options.command == "kpath":
structure = abilab.Structure.from_file(options.filepath)
print(structure.get_kpath_input_string(fmt=options.format, line_density=10))
elif options.command == "bz":
abilab.Structure.from_file(options.filepath).plot_bz()
elif options.command == "ngkpt":
d = abilab.Structure.from_file(options.filepath).calc_ksampling(options.nksmall)
print("ngkpt %d %d %d" % (d.ngkpt[0], d.ngkpt[1], d.ngkpt[2]))
print("nshiftk ", len(d.shiftk), "\nshiftk")
for s in d.shiftk:
print(" %s %s %s" % (s[0], s[1], s[2]))
elif options.command == "ktables":
structure = abilab.Structure.from_file(options.filepath)
k = Ktables(structure, options.mesh, options.is_shift, not options.no_time_reversal)
print(k)
print("")
print("NB: These results are obtained by calling spglib with the structure read from file.")
print("The k-points might differ from the ones expected by Abinit, especially if the space groups differ.")
if not options.verbose:
print("\nUse -v to obtain the BZ --> IBZ mapping.")
else:
print()
k.print_bz2ibz()
elif options.command == "abikmesh":
structure = abilab.Structure.from_file(options.filepath)
if options.kppa is None and options.ngkpt is None:
raise ValueError("Either ngkpt or kppa must be provided")
if options.kppa is not None:
print("Calling Abinit to compute the IBZ with kppa:", options.kppa, "and shiftk:", options.shiftk)
ibz = IrredZone.from_kppa(structure, options.kppa, options.shiftk,
kptopt=options.kptopt, verbose=options.verbose)
else:
print("Calling Abinit to compute the IBZ with ngkpt:", options.ngkpt, "and shiftk:", options.shiftk)
ibz = IrredZone.from_ngkpt(structure, options.ngkpt, options.shiftk,
kptopt=options.kptopt, verbose=options.verbose)
print(ibz.to_string(verbose=options.verbose))
#elif options.command == "kmesh_jhu":
# structure = abilab.Structure.from_file(options.filepath)
# ksampling = structure.ksampling_from_jhudb(kppra=1000)
# #print(ksampling)
elif options.command == "lgk":
structure = abilab.Structure.from_file(options.filepath)
spgrp = structure.abi_spacegroup
if spgrp is None:
cprint("Your file does not contain Abinit symmetry operations.", "yellow")
cprint("Will call spglib to obtain the space group (assuming time-reversal: %s)" %
(not options.no_time_reversal), "yellow")
spgrp = AbinitSpaceGroup.from_structure(structure, has_timerev=not options.no_time_reversal,
symprec=options.symprec, angle_tolerance=options.angle_tolerance)
print()
print(marquee("Structure", mark="="))
print(structure.spget_summary(verbose=options.verbose))
print("\n")
print(marquee("Little Group", mark="="))
ltk = spgrp.find_little_group(kpoint=options.kpoint)
print(ltk.to_string(verbose=options.verbose))
elif options.command == "kstar":
structure = abilab.Structure.from_file(options.filepath)
# Call spglib to get spacegroup if Abinit spacegroup is not available.
if structure.abi_spacegroup is None:
structure.spgset_abi_spacegroup(has_timerev=not options.no_time_reversal)
kpoint = Kpoint(options.kpoint, structure.reciprocal_lattice)
kstar = kpoint.compute_star(structure.abi_spacegroup, wrap_tows=True)
print("Found %s points in the star of %s\n" % (len(kstar), repr(kpoint)))
for k in kstar:
print(4 * " ", repr(k))
elif options.command == "keq":
structure = abilab.Structure.from_file(options.filepath)
# Call spglib to get spacegroup if Abinit spacegroup is not available.
if structure.abi_spacegroup is None:
structure.spgset_abi_spacegroup(has_timerev=not options.no_time_reversal)
k1, k2 = options.kpoints[:3], options.kpoints[3:6]
k1tab = structure.abi_spacegroup.symeq(k1, k2)
if k1tab.isym != -1:
print("\nk1:", k1, "and k2:", k2, "are symmetry equivalent k-points\n")
print("Related by the symmetry operation (reduced coords):\n", k1tab.op)
print("With umklapp vector Go = TO(k1) - k2 =", k1tab.g0)
else:
print(k1, "and", k2, "are NOT symmetry equivalent")
elif options.command == "mp_id":
# Get the Structure corresponding to material_id.
structure = abilab.Structure.from_mpid(options.mpid, final=True,
api_key=options.mapi_key, endpoint=options.endpoint)
# Convert to format and print it.
print(structure.convert(fmt=options.format))
elif options.command == "mp_match":
mp = abilab.mp_match_structure(options.filepath)
if not mp.structures:
cprint("No structure found in database", "yellow")
return 1
if options.notebook:
return mp.make_and_open_notebook(foreground=options.foreground)
else:
mp.print_results(fmt=options.format, verbose=options.verbose)
if options.browser:
mp.open_browser(limit=None if options.verbose == 2 else 10)
elif options.command == "mp_search":
mp = abilab.mp_search(options.chemsys_formula_id)
if not mp.structures:
cprint("No structure found in Materials Project database", "yellow")
return 1
if options.select_spgnum: mp = mp.filter_by_spgnum(options.select_spgnum)
if options.notebook:
return mp.make_and_open_notebook(foreground=options.foreground)
else:
mp.print_results(fmt=options.format, verbose=options.verbose)
if options.browser:
mp.open_browser(limit=None if options.verbose == 2 else 10)
elif options.command == "mp_pd":
if os.path.exists(options.file_or_elements):
structure = abilab.Structure.from_file(options.file_or_elements)
elements = structure.symbol_set
else:
elements = options.file_or_elements.split("-")
if options.verbose > 1: print("Building phase-diagram for elements:", elements)
with abilab.restapi.get_mprester(api_key=options.mapi_key, endpoint=options.endpoint) as rest:
pdr = rest.get_phasediagram_results(elements)
pdr.print_dataframes(verbose=options.verbose)
pdr.plot(show_unstable=options.show_unstable)
elif options.command == "cod_search":
cod = abilab.cod_search(options.formula, primitive=options.primitive)
if not cod.structures:
cprint("No structure found in COD database", "yellow")
return 1
if options.select_spgnum: cod = cod.filter_by_spgnum(options.select_spgnum)
if options.notebook:
return cod.make_and_open_notebook(foreground=options.foreground)
else:
cod.print_results(fmt=options.format, verbose=options.verbose)
elif options.command == "cod_id":
# Get the Structure from COD
structure = abilab.Structure.from_cod_id(options.cod_identifier, primitive=options.primitive)
# Convert to format and print it.
print(structure.convert(fmt=options.format))
elif options.command == "animate":
filepath = options.filepath
if any(filepath.endswith(ext) for ext in ("HIST", "HIST.nc")):
with abilab.abiopen(filepath) as hist:
structures = hist.structures
elif "XDATCAR" in filepath:
structures = Xdatcar(filepath).structures
if not structures:
raise RuntimeError("Your Xdatcar contains only one structure. Due to a bug "
"in the pymatgen routine, your structures won't be parsed correctly"
"Solution: Add another structure at the end of the file.")
else:
raise ValueError("Don't know how to handle file %s" % filepath)
xsf_write_structure(sys.stdout, structures)
else:
raise ValueError("Unsupported command: %s" % options.command)
return 0
def main():
def str_examples():
return """\
Usage example:
abistruct.py spglib filepath => Read the structure from file and analyze it with spglib.
abistruct.py convert filepath cif => Read the structure from file and print CIF file.
abistruct.py convert filepath abivars => Print the ABINIT variables defining the structure.
abistruct.py convert out_HIST abivars => Read the last structure from the HIST file and
print the corresponding Abinit variables.
abistruct.py kpath filepath => Read structure from filepath and print Abinit variables for k-path.
abistruct.py bz filepath => Read structure from filepath, plot BZ with matplotlib.
abistruct.py kmesh filepath -m 2 2 2 => Read structure from filepath, call spglib to sample the BZ with a 2,2,2 mesh,
print points in IBZ with weights.
abistruct.py abisanitize FILE => Read structure from FILE, call abisanitize, compare structures and save
"abisanitized" structure to file.
abistruct.py conventional FILE => Read structure from FILE, generate conventional structure
following doi:10.1016/j.commatsci.2010.05.010
abistruct.py visualize filepath xcrysden => Visualize the structure with XcrysDen.
abistruct.py ipython filepath => Read structure from filepath and open Ipython terminal.
abistruct.py notebook filepath => Read structure from filepath and generate jupyter notebook.
abistruct.py pmgdata mp-149 => Get structure from pymatgen database and print its JSON representation.
"""
def show_examples_and_exit(err_msg=None, error_code=1):
"""Display the usage of the script."""
sys.stderr.write(str_examples())
if err_msg: sys.stderr.write("Fatal Error\n" + err_msg + "\n")
sys.exit(error_code)
# Parent parser for commands that need to know the filepath
path_selector = argparse.ArgumentParser(add_help=False)
path_selector.add_argument(
'filepath',
nargs="?",
help=
"File with the crystalline structure (netcdf, cif, input files ...)")
parser = argparse.ArgumentParser(
epilog=str_examples(),
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('-V',
'--version',
action='version',
version="%(prog)s version " + abilab.__version__)
spgopt_parser = argparse.ArgumentParser(add_help=False)
spgopt_parser.add_argument('--symprec',
default=1e-3,
type=float,
help="""\
symprec (float): Tolerance for symmetry finding. Defaults to 1e-3,
which is fairly strict and works well for properly refined
structures with atoms in the proper symmetry coordinates. For
structures with slight deviations from their proper atomic
positions (e.g., structures relaxed with electronic structure
codes), a looser tolerance of 0.1 (the value used in Materials
Project) is often needed.""")
spgopt_parser.add_argument(
'--angle-tolerance',
default=5.0,
type=float,
help=
"angle_tolerance (float): Angle tolerance for symmetry finding. Default: 5.0"
)
# Parent parser for common options.
copts_parser = argparse.ArgumentParser(add_help=False)
copts_parser.add_argument(
'-v',
'--verbose',
default=0,
action='count', # -vv --> verbose=2
help='verbose, can be supplied multiple times to increase verbosity')
copts_parser.add_argument(
'--loglevel',
default="ERROR",
type=str,
help=
"set the loglevel. Possible values: CRITICAL, ERROR (default), WARNING, INFO, DEBUG"
)
# Create the parsers for the sub-commands
subparsers = parser.add_subparsers(
dest='command',
help='sub-command help',
description="Valid subcommands, use command --help for help")
p_spglib = subparsers.add_parser(
'spglib',
parents=[copts_parser, path_selector, spgopt_parser],
help="Analyze structure with spglib.")
# Subparser for convert command.
p_convert = subparsers.add_parser(
'convert',
parents=[copts_parser, path_selector],
help="Convert structure to the specified format.")
p_convert.add_argument(
'format',
nargs="?",
default="cif",
type=str,
help=
"Format of the output file (cif, cssr, POSCAR, json, mson, abivars).")
p_abisanitize = subparsers.add_parser(
'abisanitize',
parents=[copts_parser, path_selector, spgopt_parser],
help=
"Sanitize structure with abi_sanitize, compare structures and save result to file."
)
p_abisanitize.add_argument(
"--savefile",
default="",
type=str,
help=
'Save final structure to file. Format is detected from file extensions e.g. Si.cif'
)
p_conventional = subparsers.add_parser(
'conventional',
parents=[copts_parser, path_selector, spgopt_parser],
help=
"Gives a structure with a conventional cell according to certain standards. "
"The standards are defined in doi:10.1016/j.commatsci.2010.05.010")
p_conventional.add_argument(
"--savefile",
default="",
type=str,
help=
'Save final structure to file. Format is detected from file extensions e.g. Si.cif'
)
# Subparser for ipython.
p_ipython = subparsers.add_parser(
'ipython',
parents=[copts_parser, path_selector],
help="Open IPython shell for advanced operations on structure object.")
p_notebook = subparsers.add_parser(
'notebook',
parents=[copts_parser, path_selector],
help="Read structure from file and generate jupyter notebook.")
p_notebook.add_argument('--foreground',
action='store_true',
default=False,
help="Run jupyter notebook in the foreground.")
# Subparser for kpath.
p_kpath = subparsers.add_parser(
'kpath',
parents=[copts_parser, path_selector],
help=
"Read structure from file, generate k-path for band-structure calculations."
)
# Subparser for bz.
p_bz = subparsers.add_parser(
'bz',
parents=[copts_parser, path_selector],
help="Read structure from file, plot Brillouin zone with matplotlib.")
p_kmesh = subparsers.add_parser(
'kmesh',
parents=[copts_parser, path_selector],
help=("Read structure from filepath, call spglib to sample the BZ,"
"print k-points in the IBZ with weights."))
p_kmesh.add_argument("-m",
"--mesh",
nargs="+",
required=True,
type=int,
help="Mesh divisions e.g. 2 3 4")
p_kmesh.add_argument(
"-s",
"--is_shift",
nargs="+",
default=None,
type=int,
help=
("Three integers (spglib API). The kmesh is shifted along " +
"the axis in half of adjacent mesh points irrespective of the mesh numbers e.g. 1 1 1 "
+ "Default: Unshited mesh."))
p_kmesh.add_argument("--no-time-reversal",
default=False,
action="store_true",
help="Don't use time-reversal.")
# Subparser for visualize command.
p_visualize = subparsers.add_parser(
'visualize',
parents=[copts_parser, path_selector],
help="Visualize the structure with the specified visualizer")
p_visualize.add_argument('visualizer',
nargs="?",
default="vesta",
type=str,
help=("Visualizer name. "
"List of visualizer supported: %s" %
", ".join(Visualizer.all_visunames())))
# Subparser for pmgid command.
p_pmgdata = subparsers.add_parser(
'pmgdata',
parents=[copts_parser],
help=
"Get structure from the pymatgen database. Requires internet connection and MAPI_KEY"
)
p_pmgdata.add_argument("pmgid",
type=str,
default=None,
help="Pymatgen identifier")
p_pmgdata.add_argument(
"--mapi-key",
default=None,
help="Pymatgen MAPI_KEY. Use value in .pmgrc.yaml if not specified.")
p_pmgdata.add_argument("--endpoint",
help="Pymatgen database.",
default="https://www.materialsproject.org/rest/v2")
# Subparser for animate command.
p_animate = subparsers.add_parser(
'animate',
parents=[copts_parser, path_selector],
help=
"Read structures from HIST or XDATCAR. Print structures in Xrysden AXSF format to stdout"
)
# Parse command line.
try:
options = parser.parse_args()
except Exception as exc:
show_examples_and_exit(error_code=1)
# loglevel is bound to the string value obtained from the command line argument.
# Convert to upper case to allow the user to specify --loglevel=DEBUG or --loglevel=debug
import logging
numeric_level = getattr(logging, options.loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % options.loglevel)
logging.basicConfig(level=numeric_level)
if options.command == "spglib":
structure = abilab.Structure.from_file(options.filepath)
print(structure.spglib_summary(verbose=options.verbose))
elif options.command == "convert":
structure = abilab.Structure.from_file(options.filepath)
if options.format == "abivars":
print(structure.abi_string)
else:
s = structure.convert(format=options.format)
print(s)
elif options.command == "abisanitize":
print("\nCalling abi_sanitize to get a new structure in which:")
print(" * Structure is refined.")
print(" * Reduced to primitive settings.")
print(
" * Lattice vectors are exchanged if the triple product is negative\n"
)
structure = abilab.Structure.from_file(options.filepath)
sanitized = structure.abi_sanitize(
symprec=options.symprec,
angle_tolerance=options.angle_tolerance,
primitive=True,
primitive_standard=False)
index = [options.filepath, "abisanitized"]
dfs = abilab.frames_from_structures([structure, sanitized],
index=index,
with_spglib=True)
abilab.print_frame(dfs.lattice, title="Lattice parameters:")
abilab.print_frame(
dfs.coords,
title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
else:
#print("\nDifference between structures:")
if len(structure) == len(sanitized):
table = []
for line1, line2 in zip(
str(structure).splitlines(),
str(sanitized).splitlines()):
table.append([line1, line2])
print(
str(
tabulate(table,
headers=["Initial structure",
"Abisanitized"])))
else:
print("\nInitial structure:")
print(structure)
print("\nabisanitized structure:")
print(sanitized)
# save file.
if options.savefile:
print("Saving abisanitized structure as %s" % options.savefile)
if os.path.exists(options.savefile):
raise RuntimeError("%s already exists. Cannot overwrite" %
options.savefile)
sanitized.to(filename=options.savefile)
elif options.command == "conventional":
print(
"\nCalling get_conventional_standard_structure to get conventional structure:"
)
print(
"The standards are defined in Setyawan, W., & Curtarolo, S. (2010). "
)
print(
"High-throughput electronic band structure calculations: Challenges and tools. "
)
print(
"Computational Materials Science, 49(2), 299-312. doi:10.1016/j.commatsci.2010.05.010\n"
)
structure = abilab.Structure.from_file(options.filepath)
conv = structure.get_conventional_standard_structure(
international_monoclinic=True,
symprec=options.symprec,
angle_tolerance=options.angle_tolerance)
index = [options.filepath, "conventional"]
dfs = abilab.frames_from_structures([structure, conv],
index=index,
with_spglib=True)
abilab.print_frame(dfs.lattice, title="Lattice parameters:")
#abilab.print_frame(dfs.coords, title="Atomic positions (columns give the site index):")
if not options.verbose:
print("\nUse -v for more info")
else:
#print("\nDifference between structures:")
if len(structure) == len(conv):
table = []
for line1, line2 in zip(
str(structure).splitlines(),
str(conv).splitlines()):
table.append([line1, line2])
print(
str(
tabulate(table,
headers=["Initial structure",
"Conventional"])))
else:
print("\nInitial structure:")
print(structure)
print("\nConventional structure:")
print(conv)
# save file.
if options.savefile:
print("Saving conventional structure as %s" % options.savefile)
if os.path.exists(options.savefile):
raise RuntimeError("%s already exists. Cannot overwrite" %
options.savefile)
conv.to(filename=options.savefile)
elif options.command == "ipython":
structure = abilab.Structure.from_file(options.filepath)
print(
"Invoking Ipython, `structure` object will be available in the Ipython terminal"
)
import IPython
IPython.start_ipython(argv=[], user_ns={"structure": structure})
elif options.command == "notebook":
structure = abilab.Structure.from_file(options.filepath)
structure.make_and_open_notebook(nbpath=None,
foreground=options.foreground)
elif options.command == "visualize":
structure = abilab.Structure.from_file(options.filepath)
print(structure)
print("Visualizing structure with:", options.visualizer)
structure.visualize(options.visualizer)
elif options.command == "kpath":
structure = abilab.Structure.from_file(options.filepath)
print("# Abinit Structure")
print(structure.abi_string)
print("\n# K-path in reduced coordinates:")
print("# tolwfr 1e-20 iscf -2 getden ??")
print(" ndivsm 10")
print(" kptopt", -(len(structure.hsym_kpoints) - 1))
print(" kptbounds")
for k in structure.hsym_kpoints:
print(" %.5f %.5f %.5f" % tuple(k.frac_coords), "#", k.name)
elif options.command == "bz":
structure = abilab.Structure.from_file(options.filepath)
structure.show_bz()
elif options.command == "kmesh":
structure = abilab.Structure.from_file(options.filepath)
k = Ktables(structure, options.mesh, options.is_shift,
not options.no_time_reversal)
print(k)
print("")
print(
"NB: These results are obtained by calling spglib with the structure read from file."
)
print(
"The k-points might differ from the ones expected by Abinit, especially if the space groups differ."
)
if not options.verbose:
print("\nUse -v to obtain the BZ --> IBZ mapping.")
else:
k.print_bz2ibz()
elif options.command == "pmgdata":
# Get the Structure corresponding the a material_id.
structure = abilab.Structure.from_material_id(
options.pmgid,
final=True,
api_key=options.mapi_key,
endpoint=options.endpoint)
# Convert to json and print it.
s = structure.convert(format="json")
print(s)
elif options.command == "animate":
filepath = options.filepath
if any(filepath.endswith(ext) for ext in ("HIST", "HIST.nc")):
with abilab.abiopen(filepath) as hist:
structures = hist.structures
elif "XDATCAR" in filepath:
structures = Xdatcar(filepath).structures
if not structures:
raise RuntimeError(
"Your Xdatcar contains only one structure. Due to a bug "
"in the pymatgen routine, your structures won't be parsed correctly"
"Solution: Add another structure at the end of the file.")
else:
raise ValueError("Don't know how to handle file %s" % filepath)
xsf_write_structure(sys.stdout, structures)
else:
raise ValueError("Unsupported command: %s" % options.command)
return 0
ns = 2000 # number of structures to be included in the movie (0 for taking all structures)
skip_freq = 10 # number of structures to be skipped after each structure
ang = 0.529177249
def divide_chunks(l, n):
# looping till length l
for i in range(0, len(l), n):
yield l[i:i + n]
# Reading Files
cellfile = open(pref + '.cel').read().splitlines()
posfile = open(pref + '.pos').read().splitlines()
lats = list(divide_chunks(cellfile, 4))
coords = list(divide_chunks(posfile, len(sp) + 1))
# Loading Structures
structures = []
if (ns == 0):
ns = len(lats)
for i in range(0, ns, skip_freq):
tlat = np.loadtxt(lats[i], skiprows=1).transpose() * ang
tpos = np.loadtxt(coords[i], skiprows=1) * ang
structures.append(Structure(tlat, sp, tpos, coords_are_cartesian=True))
# Writing output to '[pref]_movie.axsf'
f = open(pref + '_movie.axsf', 'w')
xsf.xsf_write_structure(f, structures)
