def reduce(self, ibrav=None):
"""
Reduces a structure instance with nonprimitive lattice ( i.e. solves
for equivalent atomic positions) according to specified lattice type (ibrav).
Each ibrav number corresponds to a specific primitive lattice
(see QE documentation).
"""
ib = self.lattice.ibrav
if ibrav != None:
ib = ibrav
a = self.lattice.diffpy().a
b = self.lattice.diffpy().b
c = self.lattice.diffpy().c
cAB = cosd(self.lattice.diffpy().gamma)
cBC = cosd(self.lattice.diffpy().alpha)
cAC = cosd(self.lattice.diffpy().beta)
if ib > 0:
qeLattice = QELattice(ibrav = ib, a = a, b = b, c = c, cBC = cBC, \
cAC = cAC, cAB = cAB)
else:
qeLattice = QELattice(ibrav=ib, base=self.lattice.base)
qeLattice._qeInput = self._qeInput
reducedStructure = QEStructure(self)
reducedStructure.placeInLattice(qeLattice)
# collect atoms that are at equivalent position to some previous atom
duplicates = set([
a1 for i0, a0 in enumerate(reducedStructure)
for a1 in reducedStructure[i0 + 1:] if a0.element == a1.element
and equalPositions(a0.xyz, a1.xyz, eps=1e-4)
])
# Filter out duplicate atoms. Use slice assignment so that
# reducedStructure is not replaced with a list.
self.lattice = qeLattice
self[:] = [a for a in reducedStructure if not a in duplicates]
self._qeInput.structure = self
return
def reduce(self, ibrav = None):
"""
Reduces a structure instance with nonprimitive lattice ( i.e. solves
for equivalent atomic positions) according to specified lattice type (ibrav).
Each ibrav number corresponds to a specific primitive lattice
(see QE documentation).
"""
ib = self.lattice.ibrav
if ibrav != None:
ib = ibrav
a = self.lattice.diffpy().a
b = self.lattice.diffpy().b
c = self.lattice.diffpy().c
cAB = cosd(self.lattice.diffpy().gamma)
cBC = cosd(self.lattice.diffpy().alpha)
cAC = cosd(self.lattice.diffpy().beta)
if ib > 0:
qeLattice = QELattice(ibrav = ib, a = a, b = b, c = c, cBC = cBC, \
cAC = cAC, cAB = cAB)
else:
qeLattice = QELattice(ibrav = ib, base = self.lattice.base)
qeLattice._qeInput = self._qeInput
reducedStructure = QEStructure(self)
reducedStructure.placeInLattice( qeLattice )
# collect atoms that are at equivalent position to some previous atom
duplicates = set([a1
for i0, a0 in enumerate(reducedStructure) for a1 in reducedStructure[i0+1:]
if a0.element == a1.element and equalPositions(a0.xyz, a1.xyz, eps=1e-4)])
# Filter out duplicate atoms. Use slice assignment so that
# reducedStructure is not replaced with a list.
self.lattice = qeLattice
self[:] = [a for a in reducedStructure if not a in duplicates]
self._qeInput.structure = self
return
def _setReducedStructureFromDiffpyStructure(self,
structure,
ibrav,
massList=[],
psList=[]):
"""
structure - diffpy.Structure object
ibrav - Lattice index
psList - list of strings with potential names
diffpyStructure object will be modified with reduced atomic positions
"""
import copy
diffpyLattice = copy.deepcopy(structure.lattice)
a = diffpyLattice.a
b = diffpyLattice.b
c = diffpyLattice.c
cAB = cosd(diffpyLattice.gamma)
cBC = cosd(diffpyLattice.alpha)
cAC = cosd(diffpyLattice.beta)
qeLattice = QELattice(ibrav = ibrav, a = a, b = b, c = c, cBC = cBC, \
cAC = cAC, cAB = cAB)
qeLattice._qeInput = self._qeInput
self.lattice = qeLattice
# make a deep copy:
reducedStructure = Structure(atoms=structure)
reducedStructure.placeInLattice(Lattice(base=qeLattice.diffpy().base))
# collect atoms that are at equivalent position to some previous atom
duplicates = set([
a1 for i0, a0 in enumerate(reducedStructure)
for a1 in reducedStructure[i0 + 1:]
if self._element(a0) == self._element(a1)
and equalPositions(a0.xyz, a1.xyz, eps=1e-4)
])
# Filter out duplicate atoms. Use slice assignment so that
# reducedStructure is not replaced with a list.
reducedStructure[:] = [
a for a in reducedStructure if not a in duplicates
]
atomNames = []
for a in reducedStructure:
if self._element(a) not in atomNames:
atomNames.append(self._element(a))
atomicSpecies = {}
for i, elem in enumerate(atomNames):
if len(massList) - 1 < i:
mass = 0
else:
mass = massList[i]
if len(psList) - 1 < i:
ps = ''
else:
ps = psList[i]
atomicSpecies[elem] = (mass, ps)
self[:] = []
# convert to bohr units
self.lattice.setLattice(ibrav, self.lattice.a*1.889725989, \
self.lattice.b*1.889725989,
self.lattice.c*1.889725989)
for atom in reducedStructure:
elem = self._element(atom)
self.addNewAtom(atype = elem, xyz = atom.xyz, \
mass = atomicSpecies[elem][0], \
potential = atomicSpecies[elem][1],\
lattice = self.lattice, optConstraint = [])
def _setReducedStructureFromDiffpyStructure(self, structure, ibrav, massList = [], psList = []):
"""
structure - diffpy.Structure object
ibrav - Lattice index
psList - list of strings with potential names
diffpyStructure object will be modified with reduced atomic positions
"""
import copy
diffpyLattice = copy.deepcopy(structure.lattice)
a = diffpyLattice.a
b = diffpyLattice.b
c = diffpyLattice.c
cAB = cosd(diffpyLattice.gamma)
cBC = cosd(diffpyLattice.alpha)
cAC = cosd(diffpyLattice.beta)
qeLattice = QELattice(ibrav = ibrav, a = a, b = b, c = c, cBC = cBC, \
cAC = cAC, cAB = cAB)
qeLattice._qeInput = self._qeInput
self.lattice = qeLattice
# make a deep copy:
reducedStructure = Structure(atoms = structure)
reducedStructure.placeInLattice(Lattice(base=qeLattice.diffpy().base))
# collect atoms that are at equivalent position to some previous atom
duplicates = set([a1
for i0, a0 in enumerate(reducedStructure) for a1 in reducedStructure[i0+1:]
if self._element(a0) == self._element(a1) and equalPositions(a0.xyz, a1.xyz, eps=1e-4)])
# Filter out duplicate atoms. Use slice assignment so that
# reducedStructure is not replaced with a list.
reducedStructure[:] = [a for a in reducedStructure if not a in duplicates]
atomNames = []
for a in reducedStructure:
if self._element(a) not in atomNames:
atomNames.append(self._element(a))
atomicSpecies = {}
for i, elem in enumerate(atomNames):
if len(massList) - 1 < i:
mass = 0
else:
mass = massList[i]
if len(psList) - 1 < i:
ps = ''
else:
ps = psList[i]
atomicSpecies[elem] = (mass, ps)
self[:] = []
# convert to bohr units
self.lattice.setLattice(ibrav, self.lattice.a*1.889725989, \
self.lattice.b*1.889725989,
self.lattice.c*1.889725989)
for atom in reducedStructure:
elem = self._element(atom)
self.addNewAtom(atype = elem, xyz = atom.xyz, \
mass = atomicSpecies[elem][0], \
potential = atomicSpecies[elem][1],\
lattice = self.lattice, optConstraint = [])
def setReducedStructureFromDiffpyStructure(self, structure, ibrav, massList = [], psList = []):
"""
structure - diffpy.Structure object
ibrav - Lattice index
psList - list of strings with pseudopotential names
diffpyStructure object will be modified with reduced atomic positions
"""
#self.atomicSpecies = OrderedDict()
#self.optConstraints = []
#self.atomicPositionsType = 'crystal'
diffpyLattice = structure.lattice
a = diffpyLattice.a
b = diffpyLattice.b
c = diffpyLattice.c
cAB = cosd(diffpyLattice.gamma)
cBC = cosd(diffpyLattice.alpha)
cAC = cosd(diffpyLattice.beta)
qeLattice = QELattice(ibrav = ibrav, a = a, b = b, c = c, cBC = cBC, \
cAC = cAC, cAB = cAB)
self.lattice = qeLattice
# make a deep copy (does not wok now)
#reducedStructure = Structure(diffpyStructure)
reducedStructure = structure
reducedStructure.placeInLattice(Lattice(base=qeLattice.diffpy().base))
# collect atoms that are at equivalent position to some previous atom
duplicates = set([a1
for i0, a0 in enumerate(reducedStructure) for a1 in reducedStructure[i0+1:]
if self._element(a0) == self._element(a1) and equalPositions(a0.xyz, a1.xyz, eps=1e-4)])
# Filter out duplicate atoms. Use slice assignment so that
# reducedStructure is not replaced with a list.
reducedStructure[:] = [a for a in reducedStructure if not a in duplicates]
self.structure = reducedStructure
atomNames = []
for a in reducedStructure:
if self._element(a) not in atomNames:
atomNames.append(self._element(a))
#print atomNames
#print len(massList)
for i, elem in enumerate(atomNames):
if len(massList) - 1 < i:
mass = 0
else:
mass = massList[i]
if len(psList) - 1 < i:
ps = ''
else:
ps = psList[i]
#print mass, ps
# atomDict[a] =
# for i, atom in enumerate(reducedStructure):
# elem = self._element(atom)
# if len(massList) - 1 < i:
# mass = 0
# else:
# mass = massList[i]
# if len(psList) - 1 < i:
# ps = ''
# else:
# ps = psList[i]
self.atomicSpecies[elem] = AtomicSpecies(elem, mass, ps)
for atom in reducedStructure:
self.optConstraints.append([])
# convert to bohr units
self.lattice.setLattice(ibrav, self.lattice.a*1.889725989, \
self.lattice.b*1.889725989,
self.lattice.c*1.889725989)
self.nat = len(reducedStructure)
self.ntyp = len(self.atomicSpecies)
#!/usr/bin/env python
"""Express Ni FCC structure in its rhombohedral primitive cell.
"""
from diffpy.Structure import Structure
from diffpy.Structure import Lattice
from diffpy.Structure.SymmetryUtilities import equalPositions
# load Ni fcc structure, Ni.stru is in tests/testdata/
nifcc = Structure(filename='Ni.stru')
# base vectors for rhombohedral lattice in Cartesian coordinates
rhombbase = nifcc.lattice.cartesian(
[[0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.5, 0, 0.5]])
# make a deep copy of nifcc
nirhomb = Structure(nifcc)
nirhomb.placeInLattice(Lattice(base=rhombbase))
# collect atoms that are at equivalent position to some previous atom
duplicates = set([a1
for i0, a0 in enumerate(nirhomb) for a1 in nirhomb[i0+1:]
if equalPositions(a0.xyz, a1.xyz, eps=1e-4)])
# Filter out duplicate atoms. Use slice assignment so that
# nirhomb is not replaced with a list.
nirhomb[:] = [a for a in nirhomb if not a in duplicates]
# use rstrip to avoid duplicate line feed
print nirhomb.writeStr(format='discus').rstrip()
#!/usr/bin/env python
"""Express Ni FCC structure in its rhombohedral primitive cell.
"""
from diffpy.Structure import Structure
from diffpy.Structure import Lattice
from diffpy.Structure.SymmetryUtilities import equalPositions
# load Ni fcc structure, Ni.stru is in tests/testdata/
nifcc = Structure(filename='Ni.stru')
# base vectors for rhombohedral lattice in Cartesian coordinates
rhombbase = nifcc.lattice.cartesian([[0.5, 0.5, 0.0], [0.0, 0.5, 0.5],
[0.5, 0, 0.5]])
# make a deep copy of nifcc
nirhomb = Structure(nifcc)
nirhomb.placeInLattice(Lattice(base=rhombbase))
# collect atoms that are at equivalent position to some previous atom
duplicates = set([
a1 for i0, a0 in enumerate(nirhomb) for a1 in nirhomb[i0 + 1:]
if equalPositions(a0.xyz, a1.xyz, eps=1e-4)
])
# Filter out duplicate atoms. Use slice assignment so that
# nirhomb is not replaced with a list.
nirhomb[:] = [a for a in nirhomb if not a in duplicates]
# use rstrip to avoid duplicate line feed
print nirhomb.writeStr(format='discus').rstrip()
