def normal_ft_run(self):
# normal freeze-thaw cycles: everything is updated immediately
import copy
frags_new = copy.deepcopy(self._frags)
for i in range(self._cycles):
print "-" * 50
print "Beginning 3-FDE cycle (normal FT)", i
for f_new in frags_new.fragiter():
f_new.isfrozen = False
job = adffragmentsjob(frags_new,
self._basis,
settings=self._settings,
core=self._core,
pointcharges=self._pc,
fitbas=self._fitbas,
options=self._options,
fde=self._fde)
f_new.results = job.run()
f_new.results.pack_tape()
f_new.isfrozen = True
r = self.create_results_instance()
r.set_fragmentlist(frags_new)
return r
def parallel_ft_run(self):
"""
Perform parallel freeze-thaw cycles.
Fragments are updated only after each full freeze-thaw cycle.
"""
import copy
frags_old = copy.deepcopy(self._frags)
for i in range(self._cycles):
print "-" * 50
print "Beginning FDE cycle (parallel FT)", i
frags_new = copy.deepcopy(frags_old)
# frags_old: fragments of the previous cycle
# frags_new: the updated fragments
if self._adffdesettings is not None:
if self._adffdesettings.occupations is not None:
self._settings.set_occupations(
self._adffdesettings.occupations[0])
else:
self._settings.set_occupations(None)
for f_new, f_old in zip(iter(frags_new), iter(frags_old)):
f_old.isfrozen = False
job = adffragmentsjob(frags_old,
self._basis,
settings=self._settings,
core=self._core,
pointcharges=self._pc,
options=self._options,
fde=self._fde)
f_new.results = job.run()
if self._adffdesettings is not None:
if self._adffdesettings.packtape:
f_new.results.pack_tape()
f_old.isfrozen = True
self._settings.set_lshift(None)
if self._adffdesettings is not None:
if self._adffdesettings.occupations is not None:
if len(self._adffdesettings.occupations) == 2:
self._settings.set_occupations(
self._adffdesettings.occupations[1])
else:
self._settings.set_occupations(None)
frags_old = copy.deepcopy(frags_new)
r = self.create_results_instance()
r.set_fragmentlist(frags_new)
return r
def metarun(self):
results = adfaccurateembeddingresults()
# run supermolecular calculation
self.settings.set_lmo(True)
self.settings.set_save_tapes([21, 10])
self.settings.set_exactdensity(True)
results.super = adfsinglepointjob(self.supermol, self.basis, settings=self.settings).run()
# orbital localization is turned off for the other calculations
self.settings.set_lmo(False)
# fragment density is obtained from frag1 and frag2
results.frag1 = adfsinglepointjob(self.frag1, self.basis, settings=self.settings).run()
results.frag2 = adfsinglepointjob(self.frag2, self.basis, settings=self.settings).run()
# get localized orbital densities for subsystems 1 and 2
self.assign_locorbs_to_fragments(results)
adfGrid = adfgrid(results.super)
sys1_dens = results.super.get_locorb_density(grid=adfGrid, orbs=results.locorb_set1)
sys1_dens.prop = 'density scf'
# results.sys2_dens = results.super.get_locorb_density(grid=adfGrid, orbs=results.locorb_set2)
# results.sys2_dens.prop = 'density scf'
print 'reference calculations finished'
# Now comes the potential reconstruction:
self.settings.set_ncycles(self.cyc)
job = adffragmentsjob([fragment(results.frag1, [self.frag1])], self.basis, settings=self.settings)
potjob = adfpotentialjob(job, sys1_dens, potoptions=self.potoptions)
print 'Running potential reconstruction job ... '
results.pot = potjob.run()
# Calculate the error in the density
# the reconstructed density
rec_dens = results.pot.get_density(grid=adfGrid)
# the difference density
diff_dens = sys1_dens - rec_dens
# calculate integral over the difference density
results.dens_error = diff_dens.integral(func=lambda x: abs(x))
return results
def normal_ft_run(self):
"""
Normal freeze-thaw cycles: everything is updated immediately
"""
import copy
frags_new = copy.deepcopy(self._frags)
for i in range(self._cycles):
print "-" * 50
print "Beginning FDE cycle (normal FT)", i
if self._adffdesettings is not None:
self._settings.set_lshift(self._adffdesettings.vshift)
if self._adffdesettings is not None:
if self._adffdesettings.occupations is not None:
self._settings.set_occupations(
self._adffdesettings.occupations[0])
else:
self._settings.set_occupations(None)
for f_new in frags_new:
f_new.isfrozen = False
job = adffragmentsjob(frags_new,
self._basis,
settings=self._settings,
core=self._core,
pointcharges=self._pc,
options=self._options,
fde=self._fde)
f_new.results = job.run()
if self._adffdesettings is not None:
if self._adffdesettings.packtape:
f_new.results.pack_tape()
f_new.isfrozen = True
self._settings.set_lshift(None)
if self._adffdesettings is not None:
if self._adffdesettings.occupations is not None:
if len(self._adffdesettings.occupations) == 2:
self._settings.set_occupations(
self._adffdesettings.occupations[1])
else:
self._settings.set_occupations(None)
r = self.create_results_instance()
r.set_fragmentlist(frags_new)
return r
def metarun(self):
import copy
print "-" * 50
print "Beginning WFT-in-DFT embedding calculation "
print
print "Performing %i RELAX-cycles" % self._cycles
print
# first we do a normal DFT-in-DFT run
initial_frags = copy.deepcopy(self._frags)
for f in initial_frags:
# rename RELAX option to RELAXsave so that we can handle it, instead of ADF
if f.has_fdeoption("RELAX"):
f.delete_fdeoption("RELAX")
f.add_fdeoption("RELAXsave", "")
# pylint: disable-msg=W0142
dftindft_res = adffragmentsjob(initial_frags, **self._adfoptions).run()
# now construct a new list of fragments
frags = copy.deepcopy(fragmentlist(initial_frags.get_frozen_frags()))
for f in frags:
if f.has_fdeoption("RELAXsave"):
f.isfrozen = False
dirac_frag = fragment(dftindft_res, dftindft_res.get_nonfrozen_molecule(), subfrag="active", isfrozen=True)
dirac_mol = dirac_frag.get_total_molecule()
frags.append(dirac_frag)
# now run a DFT-in-DFT calculation with the Dirac-fragment frozen,
# and all DFT-relax fragments nonfrozen in order to get a grid that
# can be used for all of them
# (the Dirac step is expensive, so we want to do it only for one common grid)
#
# FIXME: Alternatively, Dirac could use several grids for exporting
#
# FIXME: we do the full DFT-in-DFT calculation, but only extracting
# the grid would be enough; maybe use some STOPAFTER option?
# pylint: disable-msg=W0142
outgrid_res = adffragmentsjob(frags, **self._adfoptions).run()
for i in range(self._cycles):
print "-" * 50
print "Performing cycle ", i + 1
print
# do the Dirac calculation
# pylint: disable-msg=W0142
dirac_res = diracsinglepointjob(dirac_mol, fdein=dftindft_res, fdeout=outgrid_res, **self._diracoptions).run()
# construct new list of fragments, update the Dirac fragment,
frags = fragmentlist(initial_frags.get_frozen_frags())
dirac_frag = diracfragment(dirac_res, dirac_mol, isfrozen=True)
frags.append(dirac_frag)
# loop over all DFT-relax fragments and update them
for f in frags:
if f.has_fdeoption("RELAXsave"):
f.isfrozen = False
# pylint: disable-msg=W0142
f.results = adffragmentsjob(frags, **self._adfoptions).run()
f.isfrozen = True
frozenfrags = frags.get_frozen_frags()
frozenfrags = [f for f in frozenfrags if not isinstance(f, diracfragment)]
initial_frags = copy.deepcopy(fragmentlist(frozenfrags))
dirac_frag = fragment(dftindft_res, dirac_mol, subfrag="active", isfrozen=False)
initial_frags.append(dirac_frag)
# run ADF DFT-in-DFT again to get a new embedding potential
#
# FIXME: rho1 is calculated by ADF in this step again.
# Instead, the rho1 calculated by Dirac should be used
dftindft_res = adffragmentsjob(initial_frags, **self._adfoptions).run()
print "-" * 50
print "Performing final DIRAC calculation "
print
dirac_res = diracsinglepointjob(dirac_mol, fdein=dftindft_res, fdeout=outgrid_res, **self._diracoptions).run()
return dirac_res
def mixed_ft_run(self):
import copy
frags_old = copy.deepcopy(self._frags)
for i in range(self._cycles):
print "-" * 50
print "Beginning 3-FDE cycle (mixed FT)", i
frags_new = copy.deepcopy(frags_old)
# frags_old: fragments of the previous cycle
# frags_new: the updated fragments
for f_new, f_old in zip(frags_new.fragiter(),
frags_old.fragiter()):
if not f_old._fdeoptions['n3fde'] == 0:
f_old.isfrozen = False
# maybe put fragment information in fragment-wise fdeoptions?
fdesettings = self._fde.copy()
for fdeoption in [
'LBdamp', 'CapRadius', 'ScfConvThresh',
'NoCapSepConv'
]:
if f_old.has_fdeoption(fdeoption):
fdesettings[fdeoption] = f_old._fdeoptions[
fdeoption]
# is it possible to make it more general?
import copy
fragsettings = copy.copy(self._settings)
if f_old.has_fragoption('ncycles'):
fragsettings.set_ncycles(f_old._fragoptions['ncycles'])
if f_old.has_fragoption('mix'):
fragsettings.set_mixing(f_old._fragoptions['mix'])
if f_old.has_fragoption('diis'):
fragsettings.set_diis(f_old._fragoptions['diis'])
if f_old.has_fragoption('adiis'):
fragsettings.set_adiis(f_old._fragoptions['adiis'])
if f_old.has_fragoption('vshift'):
fragsettings.set_lshift(f_old._fragoptions['vshift'])
if f_old.has_fragoption('cosmo'):
fragsettings.set_cosmo(f_old._fragoptions['cosmo'])
# overlap with occ?
if f_old.has_fragoption('occupations'):
fragsettings.set_occupations(
f_old._fragoptions['occupations'])
job = adffragmentsjob(frags_old,
self._basis,
settings=fragsettings,
core=self._core,
pointcharges=self._pc,
fitbas=self._fitbas,
options=self._options,
fde=fdesettings)
f_new.results = job.run()
f_new.results.pack_tape()
# subtract 1 from the n3fde (number of 3fde runs for this fragment)
f_new._fdeoptions['n3fde'] = f_old._fdeoptions['n3fde'] - 1
f_old.isfrozen = True
frags_old = copy.deepcopy(frags_new)
r = self.create_results_instance()
r.set_fragmentlist(frags_new)
return r
def metarun(self):
"""
Run the analysis job
@returns: The results of the analysis run
@rtype: adffdeanalysisresults
"""
# prepare fragments (list of results)
(frags, r_frags) = self.prepare_frags()
# make KS calculation (the reference)
self.adfsettings.set_save_tapes([10, 21])
jobKs = adffragmentsjob(frags,
basis=self.basis,
core=self.core,
settings=self.adfsettings).run()
self.adfsettings.set_save_tapes([21])
# run analysis of densities and return result
grid_super = adfgrid(jobKs)
calc_diffSoF = self.calc_diff(jobKs, r_frags, grid_super)
calc_diffSoF[0] = self.norm(calc_diffSoF[0])
# if FDE requested (not only sum-of-fragments) run FDE
results = {}
if self.settings.options == 'scaled':
options = ['SCALEDKINFUNCTIONALS']
elif self.settings.options == 'dependency':
options = ['DEPENDENCY']
else:
options = None
if self.settings.usebasis == 'True':
print '-' * 50
print 'USEBASIS: Basis functions of frozen fragments will be included in the non-frozen system'
for t in self.settings.tnad:
if self.settings.cjcorr == 'True':
fde = {'TNAD': t, 'CJCORR': 0.1}
else:
fde = {'TNAD': t}
if self.settings.runtype == ['parallelFt']:
print '\n'
print 'Testing the functional ', t
print '\n'
jobParallelFt = adffdejob(
frags,
basis=self.basis,
core=self.core,
settings=self.adfsettings,
options=options,
fde=fde,
adffdesetts=self.adffdesettings).parallel_ft_run()
calc_diffFde0 = self.calc_diff(jobKs, jobParallelFt,
grid_super)
results[t] = [calc_diffSoF, calc_diffFde0]
for i in range(0, len(results[t]) - 1):
results[t][i + 1][0] = self.norm(results[t][i + 1][0])
elif self.settings.runtype == ['normalFt']:
print '\n'
print 'Testing the functional ', t
print '\n'
fde['NORMALFT'] = ''
results[t] = [calc_diffSoF]
fde['RELAXCYCLES'] = self.settings.ncycle
jobNormalFt = adffdejob(
frags,
basis=self.basis,
core=self.core,
settings=self.adfsettings,
options=options,
fde=fde,
adffdesetts=self.adffdesettings).normal_ft_run()
calc_diffFde = self.calc_diff(jobKs, jobNormalFt, grid_super)
results[t].append(calc_diffFde)
results[t][1][0] = self.norm(results[t][1][0])
else:
print '\n'
print 'Testing the functional ', t
print '\n'
jobParallelFt = adffdejob(
frags,
basis=self.basis,
core=self.core,
settings=self.adfsettings,
options=options,
fde=fde,
adffdesetts=self.adffdesettings).parallel_ft_run()
calc_diffFde0 = self.calc_diff(jobKs, jobParallelFt,
grid_super)
calc_diffFde0[0] = self.norm(calc_diffFde0[0])
fde['NORMALFT'] = ''
results[t] = [calc_diffSoF, calc_diffFde0]
for i in range(1, self.settings.ncycle + 1):
fde['RELAXCYCLES'] = i
jobNormalFt = adffdejob(
frags,
basis=self.basis,
core=self.core,
settings=self.adfsettings,
options=options,
fde=fde,
adffdesetts=self.adffdesettings).normal_ft_run()
calc_diffFde = self.calc_diff(jobKs, jobNormalFt,
grid_super)
calc_diffFde[0] = self.norm(calc_diffFde[0])
results[t].append(calc_diffFde)
return results
