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