def get_yaff_system(self, snapshot=0):
numbers = np.array([
pt[symbol].number
for symbol in self.structure.get_chemical_symbols()
])
if snapshot == 0:
struct = self.structure
else:
struct = self.get_structure(iteration_step=snapshot,
wrap_atoms=False)
pos = struct.positions.reshape(-1, 3) * angstrom
cell = struct.cell
if cell is None:
system = System(numbers,
pos,
ffatypes=self.ffatypes,
ffatype_ids=self.ffatype_ids)
else:
system = System(numbers,
pos,
rvecs=cell * angstrom,
ffatypes=self.ffatypes,
ffatype_ids=self.ffatype_ids)
system.detect_bonds()
system.set_standard_masses()
return system
def test_uio66zrbrick_crossterms():
with log.section('NOSETEST', 2):
# Load input data for a ficticious system of an isolated
# UiO-66 brick
name = 'uio66-zr-brick/system.chk'
fn = context.get_fn(os.path.join('systems', name))
data = load_chk(fn)
system = System(data['numbers'],data['pos'],charges=data['charges'],
ffatypes=data['ffatypes'],bonds=data['bonds'],radii=data['radii'])
system.set_standard_masses()
ai = SecondOrderTaylor('ai', coords=system.pos.copy(),
grad=data['gradient'], hess=data['hessian'])
# Run QuickFF
with tmpdir('test_uio66') as dn:
fn_yaff = os.path.join(dn, 'pars_cov.txt')
fn_sys = os.path.join(dn, 'system.chk')
fn_log = os.path.join(dn, 'quickff.log')
program = DeriveFF(system, ai, Settings(consistent_cross_rvs=True,
remove_dysfunctional_cross=True,fn_yaff=fn_yaff,fn_sys=fn_sys,log_file=fn_log))
program.run()
# Check force constants of cross terms and corresponding diagonal terms
print("%50s %15s %15s"%("Basename","Cross FC","Diag FC"))
for term in program.valence.terms:
if not term.is_master(): continue
if term.basename.startswith('Cross'):
fc = program.valence.get_params(term.index, only='fc')
for i in [0,1]:
fc_diag = program.valence.get_params(term.diag_term_indexes[i], only='fc')
print("%50s %15.6f %15.6f %50s" % (term.basename,fc,fc_diag,program.valence.terms[term.diag_term_indexes[i]].basename))
if fc_diag==0.0: assert fc==0.0
def test_uio66zrbrick_crossterms():
with log.section('NOSETEST', 2):
# Load input data for a ficticious system of an isolated
# UiO-66 brick
with path('quickff.data.systems.uio66-zr-brick', 'system.chk') as fn:
data = load_chk(fn)
system = System(data['numbers'],data['pos'],charges=data['charges'],
ffatypes=data['ffatypes'],bonds=data['bonds'],radii=data['radii'])
system.set_standard_masses()
ai = SecondOrderTaylor('ai', coords=system.pos.copy(),
grad=data['gradient'], hess=data['hessian'])
# Run QuickFF
with tmpdir('test_uio66') as dn:
fn_yaff = os.path.join(dn, 'pars_cov.txt')
fn_sys = os.path.join(dn, 'system.chk')
fn_log = os.path.join(dn, 'quickff.log')
program = DeriveFF(system, ai, Settings(consistent_cross_rvs=True,
remove_dysfunctional_cross=True,fn_yaff=fn_yaff,fn_sys=fn_sys,log_file=fn_log))
program.run()
# Check force constants of cross terms and corresponding diagonal terms
print("%50s %15s %15s"%("Basename","Cross FC","Diag FC"))
for term in program.valence.terms:
if not term.is_master(): continue
if term.basename.startswith('Cross'):
fc = program.valence.get_params(term.index, only='fc')
for i in [0,1]:
fc_diag = program.valence.get_params(term.diag_term_indexes[i], only='fc')
print("%50s %15.6f %15.6f %50s" % (term.basename,fc,fc_diag,program.valence.terms[term.diag_term_indexes[i]].basename))
if fc_diag==0.0: assert fc==0.0
def read_system(name):
# Load system data
dn = 'quickff.data.systems'
if '/' in name:
words = name.split('/')
dn += '.%s' % ('.'.join(words[:-1]))
name = words[-1]
with path(dn, name) as fn:
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(
fn)
fns_wpart = glob(os.path.join(os.path.dirname(fn), 'gaussian_mbis.h5'))
# Try to load charges.
charges = None
if len(fns_wpart) > 0:
with h5.File(fns_wpart[0], 'r') as f:
charges = f['charges'][:]
# Create system object.
system = System(numbers, coords, charges=charges)
system.detect_bonds()
system.set_standard_masses()
# Load ab initio data.
ai = SecondOrderTaylor('ai',
coords=system.pos.copy(),
energy=energy,
grad=grad,
hess=hess,
pbc=pbc)
return system, ai
def read_system(name):
fn = context.get_fn('systems/%s' %name)
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(fn)
system = System(numbers, coords)
system.detect_bonds()
system.set_standard_masses()
ai = SecondOrderTaylor('ai', coords=system.pos.copy(), energy=energy, grad=grad, hess=hess, pbc=pbc)
return system, ai
def write_chk(input_dict,working_directory='.'):
# collect data and initialize Yaff system
if 'cell' in input_dict.keys() and input_dict['cell'] is not None:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, ffatypes=input_dict['ffatypes'], ffatype_ids=input_dict['ffatype_ids'], rvecs=input_dict['cell']*angstrom)
else:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, ffatypes=input_dict['ffatypes'], ffatype_ids=input_dict['ffatype_ids'])
# determine masses, bonds and ffaypes from ffatype_rules
system.detect_bonds()
system.set_standard_masses()
# write dictionary to MolMod CHK file
system.to_file(posixpath.join(working_directory,'system.chk'))
def read_system(name):
# Load system data.
fn = context.get_fn(os.path.join('systems', name))
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(fn)
# Try to load charges.
charges = None
fns_wpart = glob(os.path.join(os.path.dirname(fn), 'gaussian_mbis.h5'))
if len(fns_wpart) > 0:
with h5.File(fns_wpart[0], 'r') as f:
charges = f['charges'][:]
# Create system object.
system = System(numbers, coords, charges=charges)
system.detect_bonds()
system.set_standard_masses()
# Load ab initio data.
ai = SecondOrderTaylor('ai', coords=system.pos.copy(), energy=energy, grad=grad, hess=hess, pbc=pbc)
return system, ai
def read_system(name):
# Load system data.
fn = context.get_fn(os.path.join('systems', name))
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(fn)
# Try to load charges.
charges = None
fns_wpart = glob(os.path.join(os.path.dirname(fn), 'gaussian_mbis.h5'))
if len(fns_wpart) > 0:
with h5.File(fns_wpart[0], 'r') as f:
charges = f['charges'][:]
# Create system object.
system = System(numbers, coords, charges=charges)
system.detect_bonds()
system.set_standard_masses()
# Load ab initio data.
ai = SecondOrderTaylor('ai', coords=system.pos.copy(), energy=energy, grad=grad, hess=hess, pbc=pbc)
return system, ai
def write_chk(input_dict, working_directory='.'):
# collect data and initialize Yaff system
if 'cell' in input_dict.keys() and input_dict['cell'] is not None:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, rvecs=input_dict['cell']*angstrom, ffatypes=input_dict['ffatypes_man'], ffatype_ids=input_dict['ffatype_ids_man'])
else:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, ffatypes=input_dict['ffatypes_man'], ffatype_ids=input_dict['ffatype_ids_man'])
# determine masses, bonds and ffaypes from ffatype_rules
system.detect_bonds()
system.set_standard_masses()
# write dictionnairy to MolMod CHK file
system.to_file(posixpath.join(working_directory,'input.chk'))
# Reload input.chk as dictionairy and add AI input data
d = load_chk(posixpath.join(working_directory,'input.chk'))
assert isinstance(input_dict['aiener'], float), "AI energy not defined in input, use job.read_abintio(...)"
assert isinstance(input_dict['aigrad'], np.ndarray), "AI gradient not defined in input, use job.read_abintio(...)"
assert isinstance(input_dict['aihess'], np.ndarray), "AI hessian not defined in input, use job.read_abintio(...)"
d['energy'] = input_dict['aiener']
d['grad'] = input_dict['aigrad']
d['hess'] = input_dict['aihess']
dump_chk(posixpath.join(working_directory,'input.chk'), d)
#settings
with log.section('INIT', 2, timer='Initialization'):
settings = Settings(fn_yaff='pars_cov.txt', plot_traj='All', xyz_traj=True)
#load Gaussian Formatted Checkpoint file
fchk = FCHKFile('gaussian.fchk')
numbers = fchk.fields.get('Atomic numbers')
energy = fchk.fields.get('Total Energy')
coords = fchk.fields.get('Current cartesian coordinates').reshape([len(numbers), 3])
grad = fchk.fields.get('Cartesian Gradient').reshape([len(numbers), 3])
hess = fchk.get_hessian().reshape([len(numbers), 3, len(numbers), 3])
#Construct Yaff System file
system = System(numbers, coords)
system.detect_bonds()
system.set_standard_masses()
#Construct a QuickFF SecondOrderTaylor object containing the AI reference
with log.section('INIT', 2, timer='Initialization'):
ai = SecondOrderTaylor('ai', coords=coords, energy=energy, grad=grad, hess=hess)
#define atom types
rules = [
('H', '1 & =1%8'), #hydrogen atom with one oxygen neighbor
('O', '8 & =2%1'), #oxygen atom with two hydrogen neighbors
]
system.detect_ffatypes(rules)
#construct electrostatic force field from HE charges in gaussian_wpart.h5
with h5.File('gaussian_mbis.h5') as f:
charges = f['charges'][:]
def main():
options, fns = parse()
#define logger
if options.silent:
log.set_level('silent')
else:
if options.very_verbose:
log.set_level('highest')
elif options.verbose:
log.set_level('high')
if options.logfile is not None and isinstance(options.logfile, str):
log.write_to_file(options.logfile)
with log.section('QFF', 1, timer='Initializing'):
log.dump('Initializing system')
#read system and ab initio reference
system = None
energy = 0.0
grad = None
hess = None
rvecs = None
for fn in fns:
if fn.endswith('.fchk') or fn.endswith('.xml'):
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(
fn)
if system is None:
system = System(numbers,
coords,
rvecs=rvecs,
charges=None,
radii=None,
masses=masses)
else:
system.pos = coords.copy()
system.cell = Cell(rvecs)
system.numbers = numbers.copy()
if masses is not None: system.masses = masses.copy()
system._init_derived()
elif fn.endswith('.chk'):
sample = load_chk(fn)
if 'energy' in sample.keys(): energy = sample['energy']
if 'grad' in sample.keys(): grad = sample['grad']
elif 'gradient' in sample.keys(): grad = sample['gradient']
if 'hess' in sample.keys(): hess = sample['hess']
elif 'hessian' in sample.keys(): hess = sample['hessian']
if system is None:
system = System.from_file(fn)
else:
if 'pos' in sample.keys(): system.pos = sample['pos']
elif 'coords' in sample.keys():
system.pos = sample['coords']
if 'rvecs' in sample.keys():
system.cell = Cell(sample['rvecs'])
elif 'cell' in sample.keys():
system.cell = Cell(sample['cell'])
if 'bonds' in sample.keys(): system.bonds = sample['bonds']
if 'ffatypes' in sample.keys():
system.ffatypes = sample['ffatypes']
if 'ffatype_ids' in sample.keys():
system.ffatype_ids = sample['ffatype_ids']
system._init_derived()
else:
raise NotImplementedError('File format for %s not supported' %
fn)
assert system is not None, 'No system could be defined from input'
assert grad is not None, 'No ab initio gradient found in input'
assert hess is not None, 'No ab initio hessian found in input'
#complete the system information
if system.bonds is None: system.detect_bonds()
if system.masses is None: system.set_standard_masses()
if system.ffatypes is None:
if options.ffatypes in ['low', 'medium', 'high', 'highest']:
guess_ffatypes(system, options.ffatypes)
elif options.ffatypes is not None:
raise NotImplementedError(
'Guessing atom types from %s not implemented' %
options.ffatypes)
else:
raise AssertionError('No atom types defined')
#construct ab initio reference
ai = SecondOrderTaylor('ai',
coords=system.pos.copy(),
energy=energy,
grad=grad,
hess=hess,
pbc=pbc)
#detect a priori defined contributions to the force field
refs = []
if options.ei is not None:
if rvecs is None:
ff = ForceField.generate(system,
options.ei,
rcut=50 * angstrom)
else:
ff = ForceField.generate(system,
options.ei,
rcut=20 * angstrom,
alpha_scale=3.2,
gcut_scale=1.5,
smooth_ei=True)
refs.append(YaffForceField('EI', ff))
if options.vdw is not None:
ff = ForceField.generate(system, options.vdw, rcut=20 * angstrom)
refs.append(YaffForceField('vdW', ff))
if options.covres is not None:
ff = ForceField.generate(system, options.covres)
refs.append(YaffForceField('Cov res', ff))
#define quickff program
assert options.program_mode in allowed_programs, \
'Given program mode %s not allowed. Choose one of %s' %(
options.program_mode,
', '.join([prog for prog in allowed_programs if not prog=='BaseProgram'])
)
mode = program_modes[options.program_mode]
only_traj = 'PT_ALL'
if options.only_traj is not None: only_traj = options.only_traj.split(',')
program = mode(system,
ai,
ffrefs=refs,
fn_traj=options.fn_traj,
only_traj=only_traj,
plot_traj=options.ener_traj,
xyz_traj=options.xyz_traj,
suffix=options.suffix)
#run program
program.run()
def qff(args=None):
if args is None:
args = qff_parse_args()
else:
args = qff_parse_args(args)
#define logger
verbosity = None
if args.silent:
verbosity = 'silent'
else:
if args.very_verbose:
verbosity = 'highest'
elif args.verbose:
verbosity = 'high'
#get settings
kwargs = {
'fn_traj': args.fn_traj,
'only_traj': args.only_traj,
'program_mode': args.program_mode,
'plot_traj': args.plot_traj,
'xyz_traj': args.xyz_traj,
'suffix': args.suffix,
'log_level': verbosity,
'log_file': args.logfile,
'ffatypes': args.ffatypes,
'ei': args.ei,
'ei_rcut': args.ei_rcut,
'vdw': args.vdw,
'vdw_rcut': args.vdw_rcut,
'covres': args.covres,
}
settings = Settings(fn=args.config_file, **kwargs)
with log.section('INIT', 1, timer='Initializing'):
log.dump('Initializing system')
#read system and ab initio reference
system = None
energy = 0.0
grad = None
hess = None
pbc = None
rvecs = None
for fn in args.fn:
if fn.endswith('.fchk') or fn.endswith('.xml'):
numbers, coords, energy, grad, hess, masses, rvecs, pbc = read_abinitio(
fn)
if system is None:
system = System(numbers,
coords,
rvecs=rvecs,
charges=None,
radii=None,
masses=masses)
else:
system.pos = coords.copy()
system.cell = Cell(rvecs)
system.numbers = numbers.copy()
if masses is not None: system.masses = masses.copy()
system._init_derived()
elif fn.endswith('.chk'):
sample = load_chk(fn)
if 'energy' in list(sample.keys()): energy = sample['energy']
if 'grad' in list(sample.keys()): grad = sample['grad']
elif 'gradient' in list(sample.keys()):
grad = sample['gradient']
if 'hess' in list(sample.keys()): hess = sample['hess']
elif 'hessian' in list(sample.keys()): hess = sample['hessian']
if 'rvecs' in list(sample.keys()): pbc = [1, 1, 1]
else: pbc = [0, 0, 0]
if system is None:
system = System.from_file(fn)
else:
if 'pos' in list(sample.keys()): system.pos = sample['pos']
elif 'coords' in list(sample.keys()):
system.pos = sample['coords']
if 'rvecs' in list(sample.keys()):
system.cell = Cell(sample['rvecs'])
elif 'cell' in list(sample.keys()):
system.cell = Cell(sample['cell'])
if 'bonds' in list(sample.keys()):
system.bonds = sample['bonds']
if 'ffatypes' in list(sample.keys()):
system.ffatypes = sample['ffatypes']
if 'ffatype_ids' in list(sample.keys()):
system.ffatype_ids = sample['ffatype_ids']
system._init_derived()
else:
raise NotImplementedError('File format for %s not supported' %
fn)
assert system is not None, 'No system could be defined from input'
assert grad is not None, 'No ab initio gradient found in input'
assert hess is not None, 'No ab initio hessian found in input'
#complete the system information
if system.bonds is None: system.detect_bonds()
if system.masses is None: system.set_standard_masses()
if system.ffatypes is None:
if settings.ffatypes is not None:
set_ffatypes(system, settings.ffatypes)
else:
raise AssertionError('No atom types defined')
if settings.do_hess_negfreq_proj:
log.dump(
'Projecting negative frequencies out of the mass-weighted hessian.'
)
with log.section('SYS', 3, 'Initializing'):
hess = project_negative_freqs(hess, system.masses)
#construct ab initio reference
ai = SecondOrderTaylor('ai',
coords=system.pos.copy(),
energy=energy,
grad=grad,
hess=hess,
pbc=pbc)
#detect a priori defined contributions to the force field
refs = []
if settings.ei is not None:
if rvecs is None:
if settings.ei_rcut is None:
rcut = 50 * angstrom
else:
rcut = settings.ei_rcut
ff = ForceField.generate(system, settings.ei, rcut=rcut)
else:
if settings.ei_rcut is None:
rcut = 20 * angstrom
else:
rcut = settings.ei_rcut
ff = ForceField.generate(system,
settings.ei,
rcut=rcut,
alpha_scale=3.2,
gcut_scale=1.5,
smooth_ei=True)
refs.append(YaffForceField('EI', ff))
if settings.vdw is not None:
ff = ForceField.generate(system,
settings.vdw,
rcut=settings.vdw_rcut)
refs.append(YaffForceField('vdW', ff))
if settings.covres is not None:
ff = ForceField.generate(system, settings.covres)
refs.append(YaffForceField('Cov res', ff))
#define quickff program
assert settings.program_mode in allowed_programs, \
'Given program mode %s not allowed. Choose one of %s' %(
settings.program_mode,
', '.join([prog for prog in allowed_programs if not prog=='BaseProgram'])
)
mode = program_modes[settings.program_mode]
program = mode(system, ai, settings, ffrefs=refs)
#run program
program.run()
return program
