def test_get_vertex_indices(self):
# Create a 2x2x2 NaCl supercell
lattice = Lattice.from_parameters(a=5.0,
b=5.0,
c=5.0,
alpha=90,
beta=90,
gamma=90)
structure = Structure.from_spacegroup(
sg='Fm-3m',
lattice=lattice,
species=['Na', 'Cl'],
coords=[[0.0, 0.0, 0.0], [0.5, 0.0, 0.0]]) * [2, 2, 2]
vertex_indices = get_vertex_indices(structure=structure,
centre_species='Na',
vertex_species='Cl',
cutoff=3.0,
n_vertices=6)
c = Counter()
for vi in vertex_indices:
self.assertEqual(len(vi), 6)
c += Counter(vi)
for i in vi:
self.assertEqual(structure[i].species_string, 'Cl')
for i in range(33, 64):
self.assertEqual(c[i], 6)
def pair(self, element_a, element_b, potential, separations):
max_r = np.max(separations)
lattice = Lattice.from_parameters(10*max_r, 10*max_r, 10*max_r, 90, 90, 90)
if self.calculator_type == 'lammps':
kwargs = {'lammps_set': load_lammps_set('static')}
elif self.calculator_type == 'lammps_cython':
kwargs = {'lammps_additional_commands': ['run 0']}
async def calculate():
futures = []
for sep in separations:
coord_a = (lattice.a*0.5-(sep/2), lattice.b*0.5, lattice.c*0.5)
coord_b = (lattice.a*0.5+(sep/2), lattice.b*0.5, lattice.c*0.5)
structure = Structure(
lattice,
[element_a, element_b],
[coord_a, coord_b], coords_are_cartesian=True)
futures.append(await self.calculator.submit(
structure, potential,
properties={'energy'},
**kwargs))
return await asyncio.gather(*futures)
results = self._run_async_func(calculate())
return np.array([r['results']['energy'] for r in results])
def get_matched_structure_mapping(base: Structure, inserted: Structure,
sm: StructureMatcher):
"""
Get the mapping from the inserted structure onto the base structure,
assuming that the inserted structure sans the working ion is some kind
of SC of the base.
Args:
base: host structure, smaller cell
inserted: bigger cell
sm: StructureMatcher instance
Returns:
sc_m : supercell matrix to apply to s1 to get s2
total-t : translation to apply on s1 * sc_m to get s2
"""
s1, s2 = sm._process_species([base, inserted])
fu, _ = sm._get_supercell_size(s1, s2)
try:
val, dist, sc_m, total_t, mapping = sm._strict_match(s1,
s2,
fu=fu,
s1_supercell=True)
except TypeError:
return None
sc = s1 * sc_m
sc.lattice = Lattice.from_parameters(*sc.lattice.abc,
*sc.lattice.angles,
vesta=True) # type: ignore
return sc_m, total_t
def __init__(self):
super(ZnOCrystalMixin, self).__init__()
self.lattice = Lattice.from_parameters(
a=3.25330,
b=3.25330,
c=5.20730,
alpha=90.00000,
beta=90.00000,
gamma=120.00000,
)
self.species = [Element('Zn'), Element('O')]
self.space_group_number = 186
self.atoms_coord = [
[1 / 3, 2 / 3, 0.00000],
[1 / 3, 2 / 3, 0.37780],
]
self.atom_coords_are_cartesian = False
self.structure_tolerance = 1e-9
self.structure = None
self.cluster_size = 12
self.absorbing_atom = "O"
self.path_to_src_feff_input = '/home/yugin/PycharmProjects/neurons/data/src/feff.inp.old'
self.path_to_out_feff_input = '/home/yugin/PycharmProjects/neurons/data/src/feff.inp.new2'
# struct: Structure object, See pymatgen.core.structure.Structure.
# source: User supplied identifier, i.e. for Materials Project this
# would be the material ID number
# comment: Comment for first header line
self.header_user_identifier = 'author: Yevgen Syryanyy'
self.header_comment = 'Automatic generated feff.inp file'
def pair(self, element_a, element_b, potential, separations):
max_r = np.max(separations)
lattice = Lattice.from_parameters(10*max_r, 10*max_r, 10*max_r, 90, 90, 90)
if self.calculator_type == 'lammps':
kwargs = {'lammps_set': load_lammps_set('static')}
elif self.calculator_type == 'lammps_cython':
kwargs = {'lammps_additional_commands': ['run 0']}
async def calculate():
futures = []
for sep in separations:
coord_a = (lattice.a*0.5-(sep/2), lattice.b*0.5, lattice.c*0.5)
coord_b = (lattice.a*0.5+(sep/2), lattice.b*0.5, lattice.c*0.5)
structure = Structure(
lattice,
[element_a, element_b],
[coord_a, coord_b], coords_are_cartesian=True)
futures.append(await self.calculator.submit(
structure, potential,
properties={'energy'},
**kwargs))
return await asyncio.gather(*futures)
results = self._run_async_func(calculate())
return np.array([r['results']['energy'] for r in results])
def test_relative_to_crystal_axes(self):
lattice = Lattice.from_parameters(5, 10, 5, 90, 110, 90)
moment = [1, 0, 2]
magmom = Magmom.from_moment_relative_to_crystal_axes(moment, lattice)
self.assertTrue(
np.allclose(magmom.moment, [0.93969262, 0.0, 1.65797986]))
self.assertTrue(
np.allclose(magmom.get_moment_relative_to_crystal_axes(lattice),
moment))
def setUp(self):
coords = np.array([[0.5, 0.5, 0.5]])
atom_list = ["S"]
lattice = Lattice.from_parameters(a=1.0,
b=1.0,
c=1.0,
alpha=90,
beta=90,
gamma=90)
self.structure = Structure(lattice, atom_list, coords)
def init(self):
self.lattice = Lattice.from_parameters(
a=self.a,
b=self.b,
c=self.c,
alpha=90.00000,
beta=90.00000,
gamma=120.00000,
)
super(ZnOCrystalStructure, self).init()
def example_structure(species=None):
if not species:
species = ['S'] * 5
lattice = Lattice.from_parameters(10.0, 10.0, 10.0, 90, 90, 90)
cartesian_coords = np.array([[1.0, 1.0, 1.0], [9.0, 1.0, 1.0],
[5.0, 5.0, 5.0], [1.0, 9.0, 9.0],
[9.0, 9.0, 9.0]])
structure = Structure(coords=cartesian_coords,
lattice=lattice,
species=species,
coords_are_cartesian=True)
return structure
def test_paramdict(self):
coords = [[0.0, 0.0, 0.0], [0.75, 0.5, 0.75]]
lattice = Lattice.from_parameters(a=3.84,
b=3.84,
c=3.84,
alpha=120,
beta=90,
gamma=60)
struct = Structure(lattice, ["Si", "Si"], coords)
paradir = {
"grst": {
"do": "fromscratch",
"ngridk": "8 8 8",
"xctype": "GGA_PBE_SOL",
"gmaxvr": "14.0",
},
"xs": {
"xstype": "BSE",
"ngridk": "4 4 4",
"ngridq": "4 4 4",
"nempty": "30",
"gqmax": "3.0",
"broad": "0.07",
"tevout": "true",
"energywindow": {
"intv": "0.0 1.0",
"points": "1200"
},
"screening": {
"screentype": "full",
"nempty": "100"
},
"BSE": {
"bsetype": "singlet",
"nstlbse": "1 5 1 4"
},
},
}
test_input = ExcitingInput(struct)
test_string = test_input.write_string("unchanged", **paradir)
# read reference file
filepath = os.path.join(PymatgenTest.TEST_FILES_DIR,
"input_exciting2.xml")
tree = ET.parse(filepath)
root = tree.getroot()
ref_string = ET.tostring(root, encoding="unicode")
self.assertEqual(ref_string.strip(), test_string.strip())
def test_rdf_coordination_number(self):
# create a simple cubic lattice
coords = np.array([[0.5, 0.5, 0.5]])
atom_list = ["S"]
lattice = Lattice.from_parameters(
a=1.0, b=1.0, c=1.0, alpha=90, beta=90, gamma=90
)
structure = Structure(lattice, atom_list, coords)
rdf = RadialDistributionFunctionFast(
structures=[structure], rmax=5.0, sigma=0.01, ngrid=500
)
self.assertEqual(
np.round(rdf.get_coordination_number("S", "S")[1][110], 2), 6.0
)
def test_from_seed(self):
coords = [[0, 0, 0], [0.75, 0.5, 0.75]]
lattice = pmg_Lattice.from_parameters(a=3.84,
b=3.84,
c=3.84,
alpha=120,
beta=90,
gamma=60)
struct = Structure(lattice, ["Si", "C"], coords)
s1 = pyxtal()
s1.from_seed(struct)
s2 = s1.subgroup_once(eps=0)
pmg_s1 = s1.to_pymatgen()
pmg_s2 = s2.to_pymatgen()
self.assertTrue(sm.StructureMatcher().fit(pmg_s1, pmg_s2))
def set_vacuum(self, thick=20):
self.reset_loc()
new_lattice = self.poscar.structure.lattice
new_c = new_lattice.c - self.vacuum_thick + thick
new_lattice = Lattice.from_parameters(new_lattice.a, new_lattice.b,
new_c, new_lattice.alpha,
new_lattice.beta,
new_lattice.gamma)
min = np.mean(self.poscar.structure.frac_coords[:, 2])
newcoor = self.poscar.structure.frac_coords - [0, 0, min]
newcoor[:, 2] = newcoor[:, 2] * self.poscar.structure.lattice.c / new_c
new_structure = Structure(new_lattice,
self.poscar.structure.species,
newcoor,
coords_are_cartesian=False)
self.poscar = Poscar(new_structure)
self.reset_loc()
def test_rdf_coordination_number(self):
# create a simple cubic lattice
coords = np.array([[0.5, 0.5, 0.5]])
atom_list = ["S"]
lattice = Lattice.from_parameters(a=1.0,
b=1.0,
c=1.0,
alpha=90,
beta=90,
gamma=90)
structure = Structure(lattice, atom_list, coords)
rdf = RadialDistributionFunction.from_species(structures=[structure],
species=["S"],
rmax=5.0,
sigma=0.1,
ngrid=500)
self.assertEqual(rdf.coordination_number[100], 6.0)
def test_site_index_mapping_one(self):
a = 6.19399
lattice = Lattice.from_parameters(a, a, a, 90, 90, 90)
coords1 = np.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]])
coords2 = np.array([[0.1, 0.1, 0.1], [0.4, 0.6, 0.4]])
sites1 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords1
]
sites2 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords2
]
structure1 = Structure.from_sites(sites1)
structure2 = Structure.from_sites(sites2)
mapping = site_index_mapping(structure1, structure2)
np.testing.assert_array_equal(mapping, np.array([0, 1]))
def test_site_index_mapping_with_species_1_as_string(self):
a = 6.19399
lattice = Lattice.from_parameters(a, a, a, 90, 90, 90)
coords1 = np.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]])
coords2 = np.array([[0.4, 0.6, 0.4], [0.1, 0.1, 0.1]])
species1 = ['Na', 'Cl']
sites1 = [
PeriodicSite(species=s, coords=c, lattice=lattice)
for s, c in zip(species1, coords1)
]
sites2 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords2
]
structure1 = Structure.from_sites(sites1)
structure2 = Structure.from_sites(sites2)
mapping = site_index_mapping(structure1, structure2, species1='Na')
np.testing.assert_array_equal(mapping, np.array([1]))
def lattice(self):
# lattice matrix: basis vectors are rows
si = self["=.in"].structure_information
# todo: convert non-angstrom units
assert si.lengthunit.type == 2
lattice = Lattice.from_parameters(
*si.lattice_constants,
*si.axis_angles)
# translate to FPLO convention
# see also: https://www.listserv.dfn.de/sympa/arc/fplo-users/2020-01/msg00002.html
if self.spacegroup.crystal_system in ('trigonal', 'hexagonal'):
lattice = Lattice(lattice.matrix @ Rotation.from_rotvec([0, 0, 30], degrees=True).as_matrix())
elif self.spacegroup.crystal_system not in ('cubic', 'tetragonal', 'orthorhombic'):
log.warning('untested lattice, crystal orientation may not be correct')
return lattice
def test_site_index_mapping_with_one_to_one_mapping_raises_ValueError_one(
self):
a = 6.19399
lattice = Lattice.from_parameters(a, a, a, 90, 90, 90)
coords1 = np.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]])
coords2 = np.array([[0.4, 0.6, 0.4], [0.1, 0.1, 0.1]])
species2 = ['Na', 'Cl']
sites1 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords1
]
sites2 = [
PeriodicSite(species=s, coords=c, lattice=lattice)
for s, c in zip(species2, coords2)
]
structure1 = Structure.from_sites(sites1)
structure2 = Structure.from_sites(sites2)
with self.assertRaises(ValueError):
site_index_mapping(structure1, structure2, species2='Na')
def get_rutile_structure():
# rutile structure taken from mp-856
a = 4.832
c = 3.243
x_4f = 0.3066
lattice = Lattice.from_parameters(a, a, c, 90, 90, 90)
species = ["Sn", "Sn", "O", "O", "O", "O"]
# fmt: off
frac_coords = np.array([
[0, 0, 0], # Sn(2a)
[0.5, 0.5, 0.5], # Sn(2a)
[x_4f, x_4f, 0], # O(4f)
[1 - x_4f, 1 - x_4f, 0], # O(4f)
[0.5 - x_4f, 0.5 + x_4f, 0.5], # O(4f)
[0.5 + x_4f, 0.5 - x_4f, 0.5], # O(4f)
])
# fmt: on
structure = Structure(lattice, species, frac_coords)
return structure
def test_site_index_mapping_with_return_mapping_distances(self):
a = 6.19399
lattice = Lattice.from_parameters(a, a, a, 90, 90, 90)
coords1 = np.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]])
coords2 = np.array([[0.1, 0.1, 0.1], [0.4, 0.6, 0.4]])
sites1 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords1
]
sites2 = [
PeriodicSite(species='Na', coords=c, lattice=lattice)
for c in coords2
]
structure1 = Structure.from_sites(sites1)
structure2 = Structure.from_sites(sites2)
mapping, distances = site_index_mapping(structure1,
structure2,
return_mapping_distances=True)
np.testing.assert_array_equal(mapping, np.array([0, 1]))
expected_distance = np.sqrt(3 * ((0.1 * a)**2))
np.testing.assert_array_almost_equal(
distances, np.array([expected_distance, expected_distance]))
def get_pymatgen_structure(self):
"""
Inputs: A np.ndarry structure with standard "geometry" format
Outputs: A pymatgen core structure object with basic geometric properties
"""
if self.get_lattice_vectors():
frac_data = self.get_frac_data()
coords = frac_data[0] # frac coordinates
atoms = frac_data[1] # site labels
lattice = LatticeP.from_parameters(a=frac_data[2],
b=frac_data[3],
c=frac_data[4],
alpha=frac_data[5],
beta=frac_data[6],
gamma=frac_data[7])
structp = StructureP(lattice, atoms, coords)
return structp
else:
coords = self.get_geo_array()
symbols = self.geometry['element']
molp = Molecule(symbols, coords)
return molp
def test_relative_to_crystal_axes(self):
lattice = Lattice.from_parameters(5, 10, 5, 90, 110, 90)
moment = [1, 0, 2]
magmom = Magmom.from_moment_relative_to_crystal_axes(moment, lattice)
self.assertTrue(np.allclose(magmom.moment, [0.93969262, 0.0, 1.65797986]))
self.assertTrue(np.allclose(magmom.get_moment_relative_to_crystal_axes(lattice), moment))
def from_slabs(
cls,
substrate_slab: Slab,
film_slab: Slab,
in_plane_offset: Tuple[float, float] = (0, 0),
gap: float = 1.6,
vacuum_over_film: float = 0.0,
interface_properties: Optional[Dict] = None,
center_slab: bool = True,
) -> "Interface":
"""
Makes an interface structure by merging a substrate and film slabs
The film a- and b-vectors will be forced to be the substrate slab's
a- and b-vectors.
For now, it's suggested to use a factory method that will ensure the
appropriate interface structure is already met.
Args:
sub_slab: slab for the substrate
film_slab: slab for the film
in_plane_offset: fractional shift in plane
for the film with respect to the substrate
gap: gap between substrate and film in Angstroms
vacuum_over_film: vacuum space above the film in Angstroms
structure_properties: dictionary of misc properties for this structure
center_slab: center the slab
"""
interface_properties = interface_properties or {}
# Ensure c-axis is orthogonal to a/b plane
if isinstance(substrate_slab, Slab):
substrate_slab = substrate_slab.get_orthogonal_c_slab()
if isinstance(film_slab, Slab):
film_slab = film_slab.get_orthogonal_c_slab()
assert np.allclose(film_slab.lattice.alpha, 90, 0.1)
assert np.allclose(film_slab.lattice.beta, 90, 0.1)
assert np.allclose(substrate_slab.lattice.alpha, 90, 0.1)
assert np.allclose(substrate_slab.lattice.beta, 90, 0.1)
# Ensure sub is right-handed
# IE sub has surface facing "up"
sub_vecs = substrate_slab.lattice.matrix.copy()
if np.dot(np.cross(*sub_vecs[:2]), sub_vecs[2]) < 0:
sub_vecs[2] *= -1.0
substrate_slab.lattice = Lattice(sub_vecs)
# Find the limits of C-coords
sub_coords = substrate_slab.frac_coords
film_coords = film_slab.frac_coords
sub_min_c = np.min(sub_coords[:, 2]) * substrate_slab.lattice.c
sub_max_c = np.max(sub_coords[:, 2]) * substrate_slab.lattice.c
film_min_c = np.min(film_coords[:, 2]) * film_slab.lattice.c
film_max_c = np.max(film_coords[:, 2]) * film_slab.lattice.c
min_height = np.abs(film_max_c - film_min_c) + np.abs(sub_max_c -
sub_min_c)
# construct new lattice
abc = substrate_slab.lattice.abc[:2] + (min_height + gap +
vacuum_over_film, )
angles = substrate_slab.lattice.angles
lattice = Lattice.from_parameters(*abc, *angles)
# Get the species
species = substrate_slab.species + film_slab.species
# Get the coords
# Shift substrate to bottom in new lattice
sub_coords = np.subtract(sub_coords, [0, 0, np.min(sub_coords[:, 2])])
sub_coords[:, 2] *= substrate_slab.lattice.c / lattice.c
# Flip the film over
film_coords[:, 2] *= -1.0
film_coords[:, 2] *= film_slab.lattice.c / lattice.c
# Shift the film coords to right over the substrate + gap
film_coords = np.subtract(film_coords,
[0, 0, np.min(film_coords[:, 2])])
film_coords = np.add(
film_coords, [0, 0, gap / lattice.c + np.max(sub_coords[:, 2])])
# Build coords
coords = np.concatenate([sub_coords, film_coords])
# Shift coords to center
if center_slab:
coords = np.add(coords, [0, 0, 0.5 - np.average(coords[:, 2])])
# Only merge site properties in both slabs
site_properties = {}
site_props_in_both = set(substrate_slab.site_properties.keys()) & set(
film_slab.site_properties.keys())
for key in site_props_in_both:
site_properties[key] = [
*substrate_slab.site_properties[key],
*film_slab.site_properties[key],
]
site_properties["interface_label"] = ["substrate"] * len(
substrate_slab) + ["film"] * len(film_slab)
iface = cls(
lattice=lattice,
species=species,
coords=coords,
to_unit_cell=False,
coords_are_cartesian=False,
site_properties=site_properties,
validate_proximity=False,
in_plane_offset=in_plane_offset,
gap=gap,
vacuum_over_film=vacuum_over_film,
interface_properties=interface_properties,
)
iface.sort()
return iface
def lat_in_to_sqs(atat_lattice_in, rename=True):
"""
Convert a string-like ATAT-style lattice.in to an abstract SQS.
Parameters
----------
atat_lattice_in : str
String-like of a lattice.in in the ATAT format.
rename : bool
If True, SQS format element names will be renamed, e.g. `a_B` -> `Xab`. Default is True.
Returns
-------
SQS
Abstract SQS.
"""
# TODO: handle numeric species, e.g. 'g1'. Fixed
# Problems: parser has trouble with matching next line and we have to rename it so pymatgen
# doesn't think it's a charge.
# parse the data
parsed_data = _parse_atat_lattice(atat_lattice_in)
atat_coord_system = parsed_data[0]
atat_lattice = parsed_data[1]
atat_atoms = parsed_data[2]
# create the lattice
if len(atat_coord_system) == 3:
# we have a coordinate system matrix
coord_system = Lattice(atat_coord_system.asList()).matrix
else:
# we have length and angles
#coord_system = Lattice.from_lengths_and_angles(list(atat_coord_system[0]), list(atat_coord_system[1])).matrix
(lat_a, lat_b, lat_c) = list(atat_coord_system[0])
(lat_alpha, lat_beta, lat_gamma) = list(atat_coord_system[1])
coord_system = Lattice.from_parameters(lat_a, lat_b, lat_c, lat_alpha,
lat_beta, lat_gamma).matrix
direct_lattice = Lattice(atat_lattice.asList())
lattice = coord_system.dot(direct_lattice.matrix)
# create the list of atoms, converted to the right coordinate system
species_list = []
species_positions = []
subl_model = {
} # format {'subl_name': 'atoms_found_in_subl, e.g. "aaabbbb"'}
for position, atoms in atat_atoms:
# atoms can be a list of atoms, e.g. for not abstract SQS
if len(atoms) > 1:
raise NotImplementedError(
'Cannot parse atom list {} because the sublattice is unclear.\nParsed data: {}'
.format(atoms, atat_atoms))
atom = atoms[0]
if rename:
# change from `a_B` style to `Xab`
atom = atom.lower().split('_')
else:
raise NotImplementedError(
'Cannot rename because the atom name and sublattice name may be ambigous.'
)
# add the abstract atom to the sublattice model
subl = atom[0]
#Replace the digital by alphas, 1->a, 2->b, 3->c, ...
rep_items = re.findall(r"\d+", subl)
for rep_item in rep_items:
subl = subl.replace(rep_item, chr(96 + int(rep_item)))
subl_atom = atom[1]
subl_model[subl] = subl_model.get(subl, set()).union({subl_atom})
# add the species and position to the lists
species_list.append('X' + subl + subl_atom)
species_positions.append(list(position))
# create the structure
sublattice_model = [[e for e in sorted(list(set(subl_model[s])))]
for s in sorted(subl_model.keys())]
sublattice_names = [s for s in sorted(subl_model.keys())]
sqs = AbstractSQS(direct_lattice,
species_list,
species_positions,
coords_are_cartesian=True,
sublattice_model=sublattice_model,
sublattice_names=sublattice_names)
sqs.lattice = Lattice(lattice)
#sqs.modify_lattice(Lattice(lattice)) #This will be deprecated in v2020
return sqs
def distance_from_miller_index(site, miller_index):
point, normal = plane_from_miller_index(site.lattice, miller_index)
distance = np.dot(point - site.coords, normal) / np.linalg.norm(normal)
return distance
directory = 'runs/melting_point'
supercell = np.array([5, 5, 5], dtype=np.int)
# Inital Guess 3150
# Iter 1: 3010 K
melting_point_guess = 3010 # Kelvin
processors = '4'
lammps_command = 'lmp_mpi'
a = 4.1990858 # From evaluation of potential
lattice = Lattice.from_parameters(a, a, a, 90, 90, 90)
mg = Specie('Mg', 1.4)
o = Specie('O', -1.4)
atoms = [mg, o]
sites = [[0, 0, 0], [0.5, 0.5, 0.5]]
structure = Structure.from_spacegroup(225, lattice, atoms, sites)
initial_structure = structure * (supercell * np.array([2, 1, 1], dtype=np.int))
sorted_structure = initial_structure.get_sorted_structure(
key=partial(distance_from_miller_index, miller_index=[1, 0, 0]))
num_atoms = len(sorted_structure)
lammps_potentials = LammpsPotentials(
pair={
(mg, mg): '1309362.2766468062 0.104 0.0',
(mg, o): '9892.357 0.20199 0.0',
def load_molecule_structure():
frac_coords = [
[0.726519, 0.201998, 0.016235],
[0.775561, 0.250288, 0.064178],
[0.832526, 0.167475, 0.099370],
[0.918099, 0.101210, 0.069812],
[0.000739, 0.168940, 0.041705],
[0.889961, 0.229669, 0.142974],
[0.814331, 0.288193, 0.179060],
[0.746484, 0.088734, 0.120518],
[0.788525, 0.010777, 0.160482],
[0.663668, 0.143668, 0.024956],
[0.786126, 0.163662, 0.991722],
[0.689009, 0.265892, 0.993749],
[0.711951, 0.288002, 0.086680],
[0.834448, 0.312093, 0.054333],
[0.875310, 0.048715, 0.043226],
[0.959446, 0.050619, 0.097701],
[0.048267, 0.218407, 0.067667],
[0.056960, 0.115868, 0.021837],
[0.964699, 0.220910, 0.012857],
[0.943334, 0.288263, 0.125005],
[0.939537, 0.172011, 0.163884],
[0.767475, 0.349964, 0.159581],
[0.759199, 0.233972, 0.198677],
[0.861487, 0.328887, 0.208539],
[0.680818, 0.137077, 0.136038],
[0.715376, 0.043017, 0.088095],
[0.722655, 0.959258, 0.173358],
[0.850704, 0.957870, 0.145277],
[0.820082, 0.051357, 0.194224],
]
species = [
"C",
"C",
"N",
"C",
"C",
"C",
"C",
"C",
"C",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
"H",
]
lattice = Lattice.from_parameters(12.46433002, 12.46420102, 26.22526509,
89.99366812, 90.00714732, 90.00004617)
return Structure(coords=frac_coords, species=species, lattice=lattice)
absorbing_atom=self.absorbing_atom,
radius=self.cluster_size
)
def write_file(self):
with open(self.path_to_out_feff_input, "w") as f:
f.write(str(self._header) + "\n")
f.write(str(self._tags) + "\n")
f.write(str(self._potentials) + "\n")
f.write(str(self._atoms) + "\n")
if __name__ == '__main__':
print('-> you run ', __file__, ' file in the main mode (Top-level script environment)')
zno_lattice_init = Lattice.from_parameters(
a=3.25330, b=3.25330, c=5.20730,
alpha=90.00000, beta=90.00000, gamma=120.00000,
)
zno_structure = Structure.from_spacegroup(
sg=186, lattice=zno_lattice_init,
species=[Element('Zn'), Element('O')],
coords=[
[1 / 3, 2 / 3, 0.00000],
[1 / 3, 2 / 3, 0.37780],
],
coords_are_cartesian=False,
tol=1e-9,
)
print(zno_structure)
print(zno_structure.get_space_group_info())
out_file_name = '/home/yugin/PycharmProjects/neurons/data/src/feff.inp.new2'
file_name = '/home/yugin/PycharmProjects/neurons/data/src/feff.inp.old'
