def run(b, dm, mo): mol = gto.Mole() mol.verbose = 5 mol.output = 'out_hf-%2.1f' % b mol.atom = [ ["F", (0., 0., 0.)], ["H", (0., 0., b)], ] mol.basis = { 'F': 'cc-pvdz', 'H': 'cc-pvdz', } mol.build() mf = scf.RHF(mol) ehf.append(mf.scf(dm)) mc = mcscf.CASSCF(mf, 6, 6) if mo is None: # initial guess for b = 0.7 mo = mcscf.sort_mo(mc, mf.mo_coeff, [3, 4, 5, 6, 8, 9]) else: mo = mcscf.project_init_guess(mc, mo) e1 = mc.mc1step(mo)[0] emc.append(e1) return mf.make_rdm1(), mc.mo_coeff
def run(b, mo0=None, dm0=None): mol = gto.Mole() mol.build( verbose = 5, output = 'o2rhf-%3.2f.out' % b, atom = [ ['O', (0, 0, b/2)], ['O', (0, 0, -b/2)],], basis = 'cc-pvdz', spin = 2, symmetry = 1, ) mf = scf.RHF(mol) mf.scf(dm0) mc = mcscf.CASSCF(mf, 12, 8) if mo0 is not None: mo0 = lo.orth.vec_lowdin(mo0, mf.get_ovlp()) else: mo0 = mcscf.sort_mo(mc, mf.mo_coeff, [5,6,7,8,9,11,12,13,14,15,16,17]) mc.max_orb_stepsize = .02 mc.kernel(mo0) mc.analyze() return mf, mc
def run(b, mo0=None, dm0=None): mol = gto.Mole() mol.build( verbose = 5, output = 'o2rhf-%3.2f.out' % b, atom = [ ['O', (0, 0, b/2)], ['O', (0, 0, -b/2)],], basis = 'cc-pvdz', spin = 2, symmetry = 1, ) mf = scf.RHF(mol) mf.scf(dm0) mc = mcscf.CASSCF(mf, 12, 8) if mo0 is not None: #from pyscf import lo #mo0 = lo.orth.vec_lowdin(mo0, mf.get_ovlp()) mo0 = mcscf.project_init_guess(mc, mo0) else: mo0 = mcscf.sort_mo(mc, mf.mo_coeff, [5,6,7,8,9,11,12,13,14,15,16,17]) mc.max_orb_stepsize = .02 mc.kernel(mo0) mc.analyze() return mf, mc
def run(b, dm, mo): mol = gto.Mole() mol.verbose = 5 mol.output = 'out_hf-%2.1f' % b mol.atom = [ ["F", (0., 0., 0.)], ["H", (0., 0., b)],] mol.spin = 2 mol.basis = {'F': 'cc-pvdz', 'H': 'cc-pvdz',} mol.build() m = scf.RHF(mol) ehf.append(m.scf(dm)) mc = mcscf.CASSCF(m, 6, 6) if mo is None: mo = mcscf.sort_mo(mc, m.mo_coeff, [3,4,5,6,8,9]) else: mo = mcscf.project_init_guess(mc, mo) e1 = mc.mc1step(mo)[0] emc.append(e1) return m.make_rdm1(), mc.mo_coeff
# # Load MF orbitals # chkname = "_chk/pp_dianion_dz_b3lyp.chk" mol = chkfile.load_mol(chkname) mol.verbose = 5 mf = dft.RKS(mol) mf.__dict__.update(chkfile.load(chkname, "scf")) # # SA-MCSCF # nelecas, ncas = (4, 4) n_states = 3 weights = np.ones(n_states) / n_states mc = mcscf.CASSCF(mf, ncas, nelecas).state_average_(weights) mc.fix_spin(ss=0) mc.natorb = True mc.chkfile = "_chk/pp_dianion_dz_cas_4e_4o.chk" cas_list = [142, 143, 150, 151] mo = mcscf.sort_mo(mc, mf.mo_coeff, cas_list) mc.mc1step(mo) # # Analysis and processing # mc.analyze() molden.from_mcscf(mc, "_molden/pp_dianion_dz_cas_4e_4o.molden") molden.from_mo(mol, "_molden/pp_dianion_dz_cas_4e_4o_alt.molden", mc.mo_coeff)
cect = numpy.dot(HF_MOcoeff, numpy.dot(e_d, HF_MOcoeff.T)) f = numpy.dot(ova, numpy.dot(cect, ova)) en = numpy.diag(numpy.dot(coeff.T, numpy.dot(f, coeff))) fname = 'generated_AS_beforeCAS' from pyscf.tools import molden with open(fname + '.molden', 'w') as thefile: molden.header(mol, thefile) molden.orbital_coeff(mol, thefile, coeff, ene=en, occ=mf.mo_occ) #========================================================== mycas = mcscf.CASSCF(mf, norb, [nalpha, nbeta]) AS = range(N_Core, N_Core + N_Act) mycas.chkfile = 'cas_FeCp2.chk' # it is useful to keep the chk file for CASSCF in case you want to run some subsequent CASCI and NEVPT2 calculations mycas.fcisolver.nroots = 1 mycas.fix_spin_( ss=0 ) # in newer PYSCF it is better to specify ss which is usually your mol.spin activeMO = mcscf.sort_mo(mycas, coeff, AS, base=0) mycas.verbose = 5 mycas.max_cycle_macro = 150 mycas.kernel(activeMO) mc = mcscf.CASCI(mf, norb, [nalpha, nbeta]) mc.__dict__.update(scf.chkfile.load('cas_FeCp2.chk', 'mcscf')) mc.fcisolver.nroots = 1 mc.fix_spin_(ss=0) mc.verbose = 6 mc.kernel() ci_nevpt_e1 = mrpt.NEVPT(mc, root=0).kernel()
# Checkpoint File Name chkName = '5cene_HF.chk' mol = lib.chkfile.load_mol(chkName) mol.max_memory = 40000 mf = scf.RHF(mol) mf.__dict__.update(lib.chkfile.load(chkName, 'scf')) # Molecule CASSCF Settings norb = 22 nelec = 22 # Building SHCISCF Object mch = shci.SHCISCF(mf, norb, nelec) mo = mcscf.sort_mo(mch, mf.mo_coeff, [ 57, 59, 62, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 80, 83, 92, 96, 98, 100 ]) mch.chkfile = 'singlet_1Ag_shciscf.chk' #mo = lib.chkfile.load( mch.chkfile , 'mcscf/mo_coeff') mch.fcisolver.nPTiter = 0 # No perturbative. mch.fcisolver.sweep_iter = [0, 3, 6, 9] mch.fcisolver.sweep_epsilon = [1e-3, 5e-4, 1e-4, 8.5e-5] mch.fcisolver.stochastic = True mch.fcisolver.mpiprefix = 'mpirun -np 28' mch.fcisolver.prefix = "/rc_scratch/jasm3285" # Run SHCISCF emc = mch.mc2step(mo)[0] os.system("rm *.bkp")
solver3.spin = 3 solver3.wfnsym = 'B3' solver3.nroots = 1 solver4 = fci.direct_spin1.FCI(mol) solver4 = fci.addons.fix_spin(solver2, ss=3 / 2 * (3 / 2 + 1)) solver4.spin = 3 solver4.wfnsym = 'B4' solver4.nroots = 1 solver5 = fci.direct_spin1.FCI(mol) solver5 = fci.addons.fix_spin(solver2, ss=5 / 2 * (5 / 2 + 1)) solver5.spin = 3 solver5.wfnsym = 'A' solver5.nroots = 1 # We use the MP2 nat orbs as the entanglement is calculated for them. mc = mcscf.CASSCF(mf, len(act_mos), act_ele) mo = mcscf.sort_mo(mc, no, np.array(act_mos) + 1) mcscf.state_average_mix_(mc, [solver1, solver2, solver3, solver4, solver5], weights) ener = mc.kernel(mo) print('Excitation from A to B2: ', (solver1.e_tot - solver2.e_tot) * 27.2114, 'eV') print('Excitation from A to B3: ', (solver1.e_tot - solver3.e_tot) * 27.2114, 'eV') print('Excitation from A to B4: ', (solver1.e_tot - solver4.e_tot) * 27.2114, 'eV') print('Excitation from spin 3 to 5: ', (solver1.e_tot - solver5.e_tot) * 27.2114, 'eV')
len(mos[i]), ": ", mos[i], color.END) print("") # If state average calculations are done Check the active spaces mos = ASF.select_mroot_AS(mos) ele = asf.orbs_el_n(mf.mo_occ, mos) print(color.BOLD + 'Selected active space' + color.END, color.RED, ele, color.END, color.BOLD + 'electrons in these MOs:' + color.END, color.RED, len(mos), ": ", mos, color.END) print("") # CASSCF on DMRG nat orbs print(color.BOLD + "State average CASSCF calculations" + color.END) mc = mcscf.CASSCF(mf, len(mos), ele) mo = mcscf.sort_mo(mc, ASF.init_nat, np.array(mos) + 1) mc = mc.state_average([0.5, 0.5]) mc.fcisolver.spin = final_spin mc.fix_spin(ss=final_spin) mc.kernel(mo) # Save info cas_orbs = mc.mo_coeff mc = mcscf.CASCI(mf, len(mos), ele) mc.fcisolver.nroots = 2 mc.fix_spin(ss=final_spin) ener = mc.kernel(cas_orbs) print(color.BOLD + 'Root [0]:' + color.END, color.RED, ener[0][0], color.END,
symmetry = True, ) mf = scf.RHF(mol) mf.kernel() #mf.analyze() # # 1. State-average CASSCF to get optimal orbitals # mc = mcscf.CASSCF(mf, 6, 6) solver_ag = fci.direct_spin0_symm.FCI(mol) solver_b2u = fci.direct_spin0_symm.FCI(mol) solver_b2u.wfnsym = 'B2u' mc.fcisolver = mcscf.state_average_mix(mc, [solver_ag,solver_b2u], [.5,.5]) cas_list = [17,20,21,22,23,30] # 2pz orbitals mo = mcscf.sort_mo(mc, mf.mo_coeff, cas_list) mc.kernel(mo) #mc.analyze() mc_mo = mc.mo_coeff # # 2. Ground state wavefunction. This step can be passed you approximate it # with the state-averaged CASSCF wavefunction # mc = mcscf.CASCI(mf, 6, 6) mc.fcisolver.wfnsym = 'Ag' mc.kernel(mc_mo) ground_state = mc.ci # # 3. Exited states. In this example, B2u are bright states.