def setup_relax_select_input(self):
from os import remove, path
from aBuild.enumeration import Enumerate
from aBuild.database.crystal import Crystal
from aBuild.fitting.mtp import MTP
from aBuild.utility import unpackProtos, getAllPerms, getProtoPaths
from glob import glob
self.dataset = "gss"
# rename(path.join(self.root,'fitting/mtp')
fittingRoot = path.join(self.root, 'fitting', 'mtp')
for ilat in range(self.nEnums):
lat = self.enumDicts[ilat]["lattice"]
if lat == 'protos':
structures = getProtoPaths()
# subdivide = [structures[x:x+100] for x in range() ]
for struct in structures:
print("Proto structure:", struct)
scrambleOrder = getAllPerms(self.knary,
justCyclic='uniqueUnaries'
in struct)
for scramble in scrambleOrder:
thisCrystal = Crystal(struct, self.species)
#print("Atom counts before scramble {}".format(thisCrystal.atom_counts))
thisCrystal.scrambleAtoms(scramble)
#print("Atom counts after scramble {}".format(thisCrystal.atom_counts))
with open(path.join(fittingRoot, 'to-relax.cfg'),
'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
else:
enumLattice = Enumerate(self.enumDicts[ilat])
for struct in range(1, enumLattice.nConfigs + 1):
print("Lattice", lat, "structure:", struct)
enumLattice.generatePOSCAR(struct)
thisCrystal = Crystal(
path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct)),
self.species)
with open(path.join(fittingRoot, 'to-relax.cfg'),
'a+') as f:
f.writelines('\n'.join(thisCrystal.lines('mtprelax')))
delpath = path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct))
remove(delpath)
fittingRoot = path.join(self.root, 'fitting', 'mtp')
thisMTP = MTP(fittingRoot, settings=self.fitting)
thisMTP.calc_grade()
thisMTP.write_relaxin()
def build_relax_select_input(self):
from os import remove, path
from aBuild.enumeration import Enumerate
from aBuild.database.crystal import Crystal
from aBuild.fitting.mtp import MTP
from aBuild.utility import unpackProtos, getAllPerms
from glob import glob
fittingRoot = path.join(self.root, 'fitting', 'mtp')
for ilat in range(self.nEnums):
lat = self.enumDicts[ilat]["lattice"]
enumLattice = Enumerate(self.enumDicts[ilat])
if lat == 'protos':
structures = getProtoPaths()
for struct in structures:
scrambleOrder = getAllPerms(self.knary,
justCyclic='uniqueUnaries'
in struct)
for scramble in scrambleOrder:
thisCrystal = Crystal(struct, species=self.species)
thisCrystal.scrambleAtoms(scramble)
thisMTP = MTP(fittingRoot,
dataSet=[thisCrystal],
forRelax=True)
with open(path.join(fittingRoot, 'to-relax.cfg'),
'a+') as f:
f.writelines(thisMTP.lines)
else:
for struct in range(1, enumLattice.nEnumStructs + 1):
enumLattice.generatePOSCAR(struct)
thisCrystal = Crystal.fromPOSCAR(
enumLattice.root,
self.species,
filename="poscar.{}.{}".format(lat, struct),
title=' '.join([lat, " str #: {}"]).format(struct))
thisMTP = MTP(fittingRoot,
dataSet=[thisCrystal],
forRelax=True)
with open(path.join(fittingRoot, 'to-relax.cfg'),
'a+') as f:
f.writelines(thisMTP.lines)
delpath = path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct))
remove(delpath)
thisMTP.write_relaxin()
def build_ToRelax(self, enumDicts, species, AFM=False, start=1, end=None):
from aBuild.enumeration import Enumerate
from aBuild.utility import unpackProtos, getAllPerms, getProtoPaths
from aBuild.database.crystal import Crystal
from os import remove, path
print('Building to-relax.cfg')
print(enumDicts)
nEnums = len(enumDicts)
knary = len(species)
for ilat in range(nEnums):
lat = enumDicts[ilat]["name"]
if lat == 'protos':
structures = getProtoPaths(knary)
for struct in structures:
print("Proto structure:", struct)
scrambleOrder = getAllPerms(knary,
justCyclic='uniqueUnaries'
in struct)
for scramble in scrambleOrder:
thisCrystal = Crystal(struct, species)
#print("Atom counts before scramble {}".format(thisCrystal.atom_counts))
thisCrystal.scrambleAtoms(scramble)
if not thisCrystal.concsOK(
concRestrictions=enumDicts[ilat]["concs"]):
continue
print(thisCrystal.title)
mindist = thisCrystal.minDist
print(
mindist,
"actual min dist<-----------------------------------------------------------------------------------------------------"
)
if mindist > 2 and thisCrystal.nAtoms < 60:
if not AFM:
print('Adding to file')
#print("Atom counts after scramble {}".format(thisCrystal.atom_counts))
with open(path.join(self.root, 'to-relax.cfg'),
'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
elif thisCrystal.getAFMPlanes([1, 0, 0]):
print("Original Crystal is AFM compatible")
with open(
path.join(self.root, 'to-relax.cfg_' +
str(start)), 'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
# break
else:
print("Checking super-periodics")
superCrystal = thisCrystal.superPeriodics(2)
if superCrystal != []:
print('Found a super-Periodic that works')
print(superCrystal.basis, 'basis')
print(superCrystal.atom_counts,
'atom counts')
with open(
path.join(
self.root,
'to-relax.cfg_' + str(start)),
'a+') as f:
f.writelines('\n'.join(
superCrystal.lines('mtprelax')))
# break
else:
enumLattice = Enumerate(enumDicts[ilat])
print(end, 'end')
if end == None:
end = enumLattice.nConfigs + 1
filetag = ''
else:
filetag = '_' + str(start)
#for struct in range(enumLattice.nConfigs+1):
for struct in range(start, end):
print("Lattice", lat, "structure:", struct)
enumLattice.generatePOSCAR(struct)
thisCrystal = Crystal(
path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct)), species)
if not AFM:
print('Writing to file!!!!!', end)
with open(
path.join(self.root, 'to_relax.cfg' + filetag),
'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
elif thisCrystal.getAFMPlanes([1, 0, 0]):
print("Original Crystal is AFM compatible")
with open(
path.join(self.root, 'to_relax.cfg' + filetag),
'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
else:
print("Checking super-periodics")
superCrystal = thisCrystal.superPeriodics(2)
if superCrystal != []:
print('Found a super-Periodic that works')
with open(
path.join(self.root,
'to_relax.cfg' + filetag),
'a+') as f:
f.writelines('\n'.join(
superCrystal.lines('mtprelax')))
# print(thisCrystal.appMinDist,' approp Min Dist')
# print(thisCrystal.minDist, 'actual min dist')
# with open(path.join(self.root,'to-relax.cfg'),'a+') as f:
# f.writelines('\n'.join(thisCrystal.lines('mtprelax') ))
delpath = path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct))
remove(delpath)
end = None
nEnums = len(enumDicts)
knary = len(species)
for ilat in range(nEnums):
lat = enumDicts[ilat]["name"]
if lat == 'protos': #for prototype structures, we want to make sure that the mindist is okay
structures = getProtoPaths(knary)
for struct in structures:
print("Proto structure:", struct)
scrambleOrder = getAllPerms(knary,justCyclic = 'uniqueUnaries' in struct)
for scramble in scrambleOrder:
thisCrystal = Crystal(struct,species)
#print("Atom counts before scramble {}".format(thisCrystal.atom_counts))
thisCrystal.scrambleAtoms(scramble)
if not thisCrystal.concsOK(concRestrictions = enumDicts[ilat]["concs"]):
continue
print(thisCrystal.title)
mindist = thisCrystal.minDist
print(mindist, "actual min dist<-----------------------------------------------------------------------------------------------------")
<<<<<<< HEAD
if mindist > 2 and thisCrystal.nAtoms < 60:
if not AFM:
print('Adding to file')
#print("Atom counts after scramble {}".format(thisCrystal.atom_counts))
with open(path.join(self.root,'to-relax.cfg'),'a+') as f:
f.writelines('\n'.join(thisCrystal.lines('mtprelax') ) )
elif thisCrystal.getAFMPlanes([1,0,0]):
print("Original Crystal is AFM compatible")
def build_ToRelax(self, enums, species, AFM=False, start=1, end=None):
from aBuild.enumeration import Enumerate
from aBuild.utility import unpackProtos, getAllPerms, getProtoPaths
from aBuild.database.crystal import Crystal
from os import remove, path
print('Building to_relax.cfg')
nEnums = len(enums)
knary = len(species)
for ilat in range(nEnums):
lat = enums[ilat].lattice.lattice_name
if lat == 'protos':
structures = getProtoPaths(knary)
for struct in structures:
print("Proto structure:", struct)
scrambleOrder = getAllPerms(knary,
justCyclic='uniqueUnaries'
in struct)
for scramble in scrambleOrder:
thisCrystal = Crystal(struct, species)
#print("Atom counts before scramble {}".format(thisCrystal.atom_counts))
thisCrystal.scrambleAtoms(scramble)
if not thisCrystal.concsOK(
concRestrictions=enums[ilat]["concs"]):
continue
mindist = thisCrystal.minDist
if mindist > 2:
with open(path.join(self.root, 'to_relax.cfg'),
'a+') as f:
f.writelines('\n'.join(
thisCrystal.lines('mtprelax')))
else:
enumLattice = enums[ilat]
if end == None:
end = enumLattice.nConfigs + 1
filetag = ''
else:
filetag = '_' + str(start)
#for struct in range(enumLattice.nConfigs+1):
for struct in range(start, end):
print("Generating {} crystal structure # {}.".format(
lat, struct))
enumLattice.generatePOSCAR(struct)
# When initializing a crystal object from a poscar generated by makestr.x, I know that the crystal species is
# the same as the system species because it generates zeros in the atom counts list.
print('initializing object')
thisCrystal = Crystal.from_poscar(
path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct)), species)
thisCrystal.set_latpar(modify=enumLattice.latticeExpand)
with open(path.join(self.root, 'to_relax.cfg' + filetag),
'a+') as f:
f.writelines('\n'.join(thisCrystal.lines('mtprelax')))
delpath = path.join(enumLattice.root,
"poscar.{}.{}".format(lat, struct))
remove(delpath)