def add_pseudo(self, pseudo):
"""Add a pseudo to the Dojo."""
pseudo = Pseudo.as_pseudo(pseudo)
dojo_report = pseudo.dojo_report
# Construct the flow
flow_workdir = os.path.join(self.workdir, pseudo.basename)
flow = Flow(workdir=flow_workdir, manager=self.manager)
# Construct the flow according to the info found in the dojo report.
if not pseudo.has_hints:
# We need the hints in order to run the other tests
factory = PPConvergenceFactory()
ecut_work = factory.work_for_pseudo(pseudo, ecut_slice=slice(4, None, 1), nlaunch=4)
flow.register_work(ecut_work)
else:
# Hints are available --> construct a flow for the different trials.
dojo_trial = "deltafactor"
if dojo_trial in self.trials:
# Do we have this element in the deltafactor database?
#if not df_database().has_symbol(pseudo.symbol):
# logger.warning("Cannot find %s in deltafactor database." % pseudo.symbol)
delta_factory = DeltaFactory()
kppa = 6750 # 6750 is the value used in the deltafactor code.
kppa = 1
for accuracy in self.accuracies:
if dojo_report.has_trial(dojo_trial, accuracy): continue
ecut, pawecutdg = self._ecut_pawecutdg(pseudo, accuracy)
work = delta_factory.work_for_pseudo(pseudo, accuracy=accuracy, kppa=kppa, ecut=ecut, pawecutdg=pawecutdg)
logger.info("Adding work for %s with accuracy %s" % (dojo_trial, accuracy))
work.set_dojo_accuracy(accuracy)
flow.register_work(work)
# Test if GBRV tests are wanted.
gbrv_structs = [s.split("_")[1] for s in self.trials if s.startswith("gbrv_")]
if gbrv_structs:
gbrv_factory = GbrvFactory()
for struct_type in gbrv_structs:
dojo_trial = "gbrv_" + struct_type
for accuracy in self.accuracies:
if dojo_report.has_trial(dojo_trial, accuracy): continue
ecut, pawecutdg = self._ecut_pawecutdg(pseudo, accuracy)
work = gbrv_factory.relax_and_eos_work(pseudo, struct_type, ecut=ecut, pawecutdg=pawecutdg)
logger.info("Adding work for %s with accuracy %s" % (dojo_trial, accuracy))
work.set_dojo_accuracy(accuracy)
flow.register_work(work)
flow.allocate()
self.pseudos.append(pseudo)
self.flows.append(flow)
def test_fixes(self):
flow = Flow(workdir=test_dir,
manager=TaskManager.from_file(
os.path.join(test_dir, "taskmanager.yml")))
inp = {}
flow.register_task(input=inp)
flow.allocate()
def open(cls, obj, nids=None, **kwargs):
"""
Flexible constructor. obj can be a :class:`Flow` or a string with the directory containing the Flow.
nids is an optional list of :class:`Node` identifiers used to filter the set of :class:`Task` in the Flow.
"""
has_dirpath = False
if is_string(obj):
try:
obj = Flow.pickle_load(obj)
except:
has_dirpath = True
items = []
if not has_dirpath:
# We have a Flow. smeth is the name of the Task method used to open the file.
smeth = "open_" + cls.EXT.lower()
for task in obj.iflat_tasks(nids=nids, status=obj.S_OK):
open_method = getattr(task, smeth, None)
if open_method is None: continue
ncfile = open_method()
if ncfile is not None: items.append((task.pos_str, ncfile))
else:
# directory --> search for files with the appropriate extension and open it with abiopen.
if nids is not None:
raise ValueError(
"nids cannot be used when obj is a directory.")
from abipy.abilab import abiopen
for dirpath, dirnames, filenames in os.walk(obj):
filenames = [
f for f in filenames if f.endswith(cls.EXT + ".nc")
]
for f in filenames:
ncfile = abiopen(f)
if ncfile is not None:
items.append((ncfile.filepath, ncfile))
new = cls(*items)
# Save a reference to the initial object so that we can reload it if needed
#new._initial_object = obj
return new
def open(cls, obj, nids=None, **kwargs):
"""
Flexible constructor. obj can be a :class:`Flow` or a string with the directory containing the Flow.
nids is an optional list of :class:`Node` identifiers used to filter the set of :class:`Task` in the Flow.
"""
has_dirpath = False
if is_string(obj):
try:
obj = Flow.pickle_load(obj)
except:
has_dirpath = True
items = []
if not has_dirpath:
# We have a Flow. smeth is the name of the Task method used to open the file.
smeth = "open_" + cls.EXT.lower()
for task in obj.iflat_tasks(nids=nids, status=obj.S_OK):
open_method = getattr(task, smeth, None)
if open_method is None: continue
ncfile = open_method()
if ncfile is not None: items.append((task.pos_str, ncfile))
else:
# directory --> search for files with the appropriate extension and open it with abiopen.
if nids is not None: raise ValueError("nids cannot be used when obj is a directory.")
from abipy.abilab import abiopen
for dirpath, dirnames, filenames in os.walk(obj):
filenames = [f for f in filenames if f.endswith(cls.EXT + ".nc")]
for f in filenames:
ncfile = abiopen(f)
if ncfile is not None: items.append((ncfile.filepath, ncfile))
new = cls(*items)
# Save a reference to the initial object so that we can reload it if needed
#new._initial_object = obj
return new
def create(self):
"""
create single abinit G0W0 flow
"""
manager = 'slurm' if 'ceci' in self.spec['mode'] else 'shell'
# an AbiStructure object has an overwritten version of get_sorted_structure that sorts according to Z
# this could also be pulled into the constructor of Abistructure
#abi_structure = self.structure.get_sorted_structure()
from abipy import abilab
item = copy.copy(self.structure.item)
self.structure.__class__ = abilab.Structure
self.structure = self.structure.get_sorted_structure_z()
self.structure.item = item
abi_structure = self.structure
manager = TaskManager.from_user_config()
# Initialize the flow.
flow = Flow(self.work_dir, manager, pickle_protocol=0)
# flow = Flow(self.work_dir, manager)
# kpoint grid defined over density 40 > ~ 3 3 3
if self.spec['converge'] and not self.all_converged:
# (2x2x2) gamma centered mesh for the convergence test on nbands and ecuteps
# if kp_in is present in the specs a kp_in X kp_in x kp_in mesh is used for the convergence studie
if 'kp_in' in self.spec.keys():
if self.spec['kp_in'] > 9:
print('WARNING:\nkp_in should be < 10 to generate an n x n x n mesh\nfor larger values a grid with '
'density kp_in will be generated')
scf_kppa = self.spec['kp_in']
else:
scf_kppa = 2
else:
# use the specified density for the final calculation with the converged nbands and ecuteps of other
# stand alone calculations
scf_kppa = self.spec['kp_grid_dens']
gamma = True
# 'standard' parameters for stand alone calculation
nb = self.get_bands(self.structure)
nscf_nband = [10 * nb]
nksmall = None
ecuteps = [8]
ecutsigx = 44
extra_abivars = dict(
paral_kgb=1,
inclvkb=2,
ecut=44,
pawecutdg=88,
gwmem='10',
getden=-1,
istwfk="*1",
timopt=-1,
nbdbuf=8
)
# read user defined extra abivars from file 'extra_abivars' should be dictionary
extra_abivars.update(read_extra_abivars())
#self.bands_fac = 0.5 if 'gwcomp' in extra_abivars.keys() else 1
#self.convs['nscf_nbands']['test_range'] = tuple([self.bands_fac*x for x in self.convs['nscf_nbands']['test_range']])
response_models = ['godby']
if 'ppmodel' in extra_abivars.keys():
response_models = [extra_abivars.pop('ppmodel')]
if self.option is not None:
for k in self.option.keys():
if k in ['ecuteps', 'nscf_nbands']:
pass
else:
extra_abivars.update({k: self.option[k]})
if k == 'ecut':
extra_abivars.update({'pawecutdg': self.option[k]*2})
try:
grid = read_grid_from_file(s_name(self.structure)+".full_res")['grid']
all_done = read_grid_from_file(s_name(self.structure)+".full_res")['all_done']
workdir = os.path.join(s_name(self.structure), 'w'+str(grid))
except (IOError, OSError):
grid = 0
all_done = False
workdir = None
if not all_done:
if (self.spec['test'] or self.spec['converge']) and not self.all_converged:
if self.spec['test']:
print('| setting test calculation')
tests = SingleAbinitGWWork(self.structure, self.spec).tests
response_models = []
else:
if grid == 0:
print('| setting convergence calculations for grid 0')
#tests = SingleAbinitGWWorkFlow(self.structure, self.spec).convs
tests = self.convs
else:
print('| extending grid')
#tests = expand(SingleAbinitGWWorkFlow(self.structure, self.spec).convs, grid)
tests = expand(self.convs, grid)
ecuteps = []
nscf_nband = []
for test in tests:
if tests[test]['level'] == 'scf':
if self.option is None:
extra_abivars.update({test + '_s': tests[test]['test_range']})
elif test in self.option:
extra_abivars.update({test: self.option[test]})
else:
extra_abivars.update({test + '_s': tests[test]['test_range']})
else:
for value in tests[test]['test_range']:
if test == 'nscf_nbands':
nscf_nband.append(value * self.get_bands(self.structure))
#scr_nband takes nscf_nbands if not specified
#sigma_nband takes scr_nbands if not specified
if test == 'ecuteps':
ecuteps.append(value)
if test == 'response_model':
response_models.append(value)
elif self.all_converged:
print('| setting up for testing the converged values at the high kp grid ')
# add a bandstructure and dos calculation
nksmall = 30
# in this case a convergence study has already been performed.
# The resulting parameters are passed as option
ecuteps = [self.option['ecuteps'], self.option['ecuteps'] + self.convs['ecuteps']['test_range'][1] -
self.convs['ecuteps']['test_range'][0]]
nscf_nband = [self.option['nscf_nbands'], self.option['nscf_nbands'] + self.convs['nscf_nbands'][
'test_range'][1] - self.convs['nscf_nbands']['test_range'][0]]
# for option in self.option:
# if option not in ['ecuteps', 'nscf_nband']:
# extra_abivars.update({option + '_s': self.option[option]})
else:
print('| all is done for this material')
return
logger.info('ecuteps : ', ecuteps)
logger.info('extra : ', extra_abivars)
logger.info('nscf_nb : ', nscf_nband)
work = g0w0_extended(abi_structure, self.pseudo_table, scf_kppa, nscf_nband, ecuteps, ecutsigx,
accuracy="normal", spin_mode="unpolarized", smearing=None, response_models=response_models,
charge=0.0, sigma_nband=None, scr_nband=None, gamma=gamma, nksmall=nksmall, **extra_abivars)
flow.register_work(work, workdir=workdir)
return flow.allocate()
from pymatgen.io.abinitio.flows import Flow
from pymatgen.io.abinitio.strategies import RelaxStrategy
from pymatgen.io.abinitio.abiobjects import KSampling, RelaxationMethod, AbiStructure
from pymatgen.core import Structure
from myscripts.pseudos import all_pseudos
scratchdir = '/p/lscratchd/damewood'
basename = '2014_Trilayer/abinit_6z'
workdir = os.path.join(scratchdir,basename)
logging.basicConfig()
structure = Structure.from_file('trilayer_6z.json')
manager = TaskManager.from_user_config()
ksampling = KSampling(mode='monkhorst',kpts=((6,6,2),), kpt_shifts=((0.5,0.5,0.5),(0.5,0.0,0.0),(0.0,0.5,0.0),(0.0,0.0,0.5)))
relax_ion = RelaxationMethod(ionmov = 2, optcell = 0)
relax_ioncell = RelaxationMethod(ionmov = 2, optcell = 1)
pseudos = all_pseudos()
flow = Flow(manager = manager, workdir = os.path.join(workdir, 'trilayer_6z'))
spins = numpy.zeros([len(structure),3])
spins[:4,2] = 3.
ion_input = RelaxStrategy(structure, pseudos, ksampling,
relax_ion, accuracy="high", smearing = "fermi_dirac:0.025 eV",
ecut = 40., pawecutdg = 80., chkprim = 0, tolmxf = 5.e-6, spinat = spins,
restartxf = -2, nband = 60, nstep = 100)
ioncell_input = ion_input.copy()
ioncell_input.relax_algo = relax_ioncell
work = RelaxWork(ion_input, ioncell_input, manager = manager)
flow.register_work(work, workdir = 'relax')
flow = flow.allocate()
def test_fixes(self):
flow = Flow(workdir=test_dir, manager=TaskManager.from_file(os.path.join(test_dir, "taskmanager.yml")))
inp = {}
flow.register_task(input=inp)
flow.allocate()
def create(self):
"""
create single abinit G0W0 flow
"""
manager = 'slurm' if 'ceci' in self.spec['mode'] else 'shell'
# an AbiStructure object has an overwritten version of get_sorted_structure that sorts according to Z
# this could also be pulled into the constructor of Abistructure
#abi_structure = self.structure.get_sorted_structure()
from abipy import abilab
item = copy.copy(self.structure.item)
self.structure.__class__ = abilab.Structure
self.structure = self.structure.get_sorted_structure_z()
self.structure.item = item
abi_structure = self.structure
manager = TaskManager.from_user_config()
# Initialize the flow.
flow = Flow(self.work_dir, manager, pickle_protocol=0)
# flow = Flow(self.work_dir, manager)
# kpoint grid defined over density 40 > ~ 3 3 3
if self.spec['converge'] and not self.all_converged:
# (2x2x2) gamma centered mesh for the convergence test on nbands and ecuteps
# if kp_in is present in the specs a kp_in X kp_in x kp_in mesh is used for the convergence studie
if 'kp_in' in self.spec.keys():
if self.spec['kp_in'] > 9:
print(
'WARNING:\nkp_in should be < 10 to generate an n x n x n mesh\nfor larger values a grid with '
'density kp_in will be generated')
scf_kppa = self.spec['kp_in']
else:
scf_kppa = 2
else:
# use the specified density for the final calculation with the converged nbands and ecuteps of other
# stand alone calculations
scf_kppa = self.spec['kp_grid_dens']
gamma = True
# 'standard' parameters for stand alone calculation
scf_nband = self.get_bands(self.structure)
nscf_nband = [10 * scf_nband]
nksmall = None
ecuteps = [8]
ecutsigx = 44
extra_abivars = dict(paral_kgb=1,
inclvkb=2,
ecut=44,
pawecutdg=88,
gwmem='10',
getden=-1,
istwfk="*1",
timopt=-1,
nbdbuf=8,
prtsuscep=0)
# read user defined extra abivars from file 'extra_abivars' should be dictionary
extra_abivars.update(read_extra_abivars())
#self.bands_fac = 0.5 if 'gwcomp' in extra_abivars.keys() else 1
#self.convs['nscf_nbands']['test_range'] = tuple([self.bands_fac*x for x in self.convs['nscf_nbands']['test_range']])
response_models = ['godby']
if 'ppmodel' in extra_abivars.keys():
response_models = [extra_abivars.pop('ppmodel')]
if self.option is not None:
for k in self.option.keys():
if k in ['ecuteps', 'nscf_nbands']:
pass
else:
extra_abivars.update({k: self.option[k]})
if k == 'ecut':
extra_abivars.update({'pawecutdg': self.option[k] * 2})
try:
grid = read_grid_from_file(s_name(self.structure) +
".full_res")['grid']
all_done = read_grid_from_file(
s_name(self.structure) + ".full_res")['all_done']
workdir = os.path.join(s_name(self.structure), 'w' + str(grid))
except (IOError, OSError):
grid = 0
all_done = False
workdir = None
if not all_done:
if (self.spec['test']
or self.spec['converge']) and not self.all_converged:
if self.spec['test']:
print('| setting test calculation')
tests = SingleAbinitGWWork(self.structure, self.spec).tests
response_models = []
else:
if grid == 0:
print('| setting convergence calculations for grid 0')
#tests = SingleAbinitGWWorkFlow(self.structure, self.spec).convs
tests = self.convs
else:
print('| extending grid')
#tests = expand(SingleAbinitGWWorkFlow(self.structure, self.spec).convs, grid)
tests = expand(self.convs, grid)
ecuteps = []
nscf_nband = []
for test in tests:
if tests[test]['level'] == 'scf':
if self.option is None:
extra_abivars.update(
{test + '_s': tests[test]['test_range']})
elif test in self.option:
extra_abivars.update({test: self.option[test]})
else:
extra_abivars.update(
{test + '_s': tests[test]['test_range']})
else:
for value in tests[test]['test_range']:
if test == 'nscf_nbands':
nscf_nband.append(
value * self.get_bands(self.structure))
#scr_nband takes nscf_nbands if not specified
#sigma_nband takes scr_nbands if not specified
if test == 'ecuteps':
ecuteps.append(value)
if test == 'response_model':
response_models.append(value)
elif self.all_converged:
print(
'| setting up for testing the converged values at the high kp grid '
)
# add a bandstructure and dos calculation
if os.path.isfile('bands'):
nksmall = -30
#negative value > only bandstructure
else:
nksmall = 30
# in this case a convergence study has already been performed.
# The resulting parameters are passed as option
ecuteps = [
self.option['ecuteps'], self.option['ecuteps'] +
self.convs['ecuteps']['test_range'][1] -
self.convs['ecuteps']['test_range'][0]
]
nscf_nband = [
self.option['nscf_nbands'], self.option['nscf_nbands'] +
self.convs['nscf_nbands']['test_range'][1] -
self.convs['nscf_nbands']['test_range'][0]
]
# for option in self.option:
# if option not in ['ecuteps', 'nscf_nband']:
# extra_abivars.update({option + '_s': self.option[option]})
else:
print('| all is done for this material')
return
logger.info('ecuteps : ', ecuteps)
logger.info('extra : ', extra_abivars)
logger.info('nscf_nb : ', nscf_nband)
work = g0w0_extended_work(abi_structure,
self.pseudo_table,
scf_kppa,
nscf_nband,
ecuteps,
ecutsigx,
scf_nband,
accuracy="normal",
spin_mode="unpolarized",
smearing=None,
response_models=response_models,
charge=0.0,
sigma_nband=None,
scr_nband=None,
gamma=gamma,
nksmall=nksmall,
**extra_abivars)
flow.register_work(work, workdir=workdir)
return flow.allocate()
