def calculator_factory(name, **kwargs):
"""Create an ASE calculator factory."""
if name == 'abinit':
from ase.calculators.abinit import Abinit
return CalculatorFactory(Abinit, 'Abinit', 'label', **kwargs)
if name == 'aims':
from ase.calculators.aims import Aims
return CalculatorFactory(Aims, 'aims', 'label', **kwargs)
if name == 'nwchem':
from ase.calculators.nwchem import NWChem
return CalculatorFactory(NWChem, 'NWChem', 'label', 'no k-points',
**kwargs)
if name == 'asap':
from asap3 import EMT
return CalculatorFactory(EMT, 'Asap', None, 'no k-points', **kwargs)
if name == 'elk':
from ase.calculators.elk import ELK
return CalculatorFactory(ELK, 'ELK', 'label', **kwargs)
if name == 'fleur':
from ase.calculators.fleur import FLEUR
return CalculatorFactory(FLEUR, 'FLEUR', 'workdir', **kwargs)
if name == 'gpaw':
from gpaw.factory import GPAWFactory
return GPAWFactory(**kwargs)
if name == 'hotbit':
from hotbit import Calculator
return CalculatorFactory(Calculator, 'Hotbit', 'txt', 'no k-points',
**kwargs)
if name == 'jacapo':
from ase.calculators.jacapo import Jacapo
return CalculatorFactory(Jacapo, 'Jacapo', 'nc', **kwargs)
if name == 'vasp':
from ase.calculators.vasp import Vasp
return CalculatorFactory(Vasp, 'Vasp', None, **kwargs)
classname = classnames.get(name, name.title())
module = __import__('ase.calculators.' + name, {}, None, [classname])
Class = getattr(module, classname)
if name in ['emt', 'gaussian', 'lammpsrun', 'lj', 'mopac', 'morse']:
kpts = 'no k-points'
else:
kpts = None
if name in ['emt', 'lj', 'morse']:
label = None
else:
label = 'label'
return CalculatorFactory(Class, classname, label, kpts, **kwargs)
calcopts.update({'nbands': -int(nbands)})
if run.startswith('szpdzp'):
calcopts.update({'basis': 'szp(dzp)'})
if run.startswith('szdzp'):
calcopts.update({'basis': 'sz(dzp)'})
if run.startswith('dzp'):
calcopts.update({'basis': 'dzp'})
if 'cg' in run:
calcopts.update({'eigensolver': 'cg'})
else:
calcopts.update({'eigensolver': 'rmm-diis'})
if run.startswith('cgdzp'):
calcopts.update({'basis': 'dzp'})
calcopts.update({'mixer': eval(rundefs[run])})
calcfactory = GPAWFactory(**calcopts)
collection = Collection(data, atom_names + molecule_names, cell)
task = Task(
calcfactory=calcfactory,
tag=tag,
use_lock_files=True,
collection=collection,
cell=cell,
)
keys = collection.keys()
for m in ['Na2', 'NaCl']: # those seem to need cg
keys.remove(m)
task.run(keys)
if optimizer is not None:
tag += '_%s' % optimizer
calcopts_default = {
'mode': 'lcao',
'basis': 'dzp',
'xc': 'PBE',
'width': 0.0,
'fixmom': True,
'nbands': -2,
# make systems converge
'mixer': Mixer(0.05, 2),
'maxiter': 300,
}
calcfactory_default = GPAWFactory(**calcopts_default)
calcopts_d16 = calcopts_default.copy()
calcopts_d16.update({'convergence': {'density': 1.e-6}})
calcfactory_d16 = GPAWFactory(**calcopts_d16)
calcfactory = calcfactory_default
collection = Collection(data, names, cell)
taskopts = {'fmax': 0.05, 'steps': 100}
if optimizer is not None:
if 'D16' not in optimizer:
taskopts.update({'optimizer': optimizer})
calcfactory = calcfactory_default
else:
if len(sys.argv) == 1:
optimizer = None
else:
optimizer = sys.argv[1]
tag = 'htb_pw'
if optimizer is not None:
tag += '_%s' % optimizer
calcfactory = GPAWFactory(
mode=PW(),
xc='PBE',
width=0.1,
maxiter=400,
mixer=Mixer(0.10, 2),
eigensolver='cg',
# avoid problems with band parallelization
communicator=serial_comm,
)
taskopts = {'sfmax': 0.01, 'ssteps': 50}
if optimizer is not None:
taskopts.update({'soptimizer': optimizer})
task = Task(xc='LDA',
calcfactory=calcfactory,
tag=tag,
use_lock_files=True,
**taskopts)
