Multiwfn official website: //www.umsyar.com/multiwfn. Multiwfn forum in Chinese: http://bbs.keinsci.com/wfn
You are not logged in.
Pages: 1
Hi, my suggestion is to use the MRSF-TDDFT method in the free software package GAMESS. The SF-TDDFT method in ORCA/GAMESS suffers from the spin-contamination problem during practical calculations, while MRSF-TDDFT is almost exact spin-pure (whose spin-contamination can hardly be seen). It is very easy to perform an MRSF-TDDFT calculation. Here is an example:
Step 1. perform an ROKS (i.e. RODFT) calculation
Open-shell ROKS calculations are usually not easy. It is recommended to use PySCF/Gaussian to perform this calculation. The PySCF input file is show below
from pyscf import gto, dft, lib
from mokit.lib.py2fch_direct import fchk
lib.num_threads(64)
mol = gto.M()
mol.atom = '''
C -0.12264859 0.00599759 -0.75931820
C -0.13393227 0.05086047 0.75572332
O 1.29017598 0.03740604 -0.91156021
O 1.12879647 -0.57344495 0.94545004
H -0.54539878 -0.92543383 -1.16182063
H -0.91791476 -0.55372886 1.23567184
H -0.13429527 1.07605238 1.15229831
H -0.56478278 0.88229116 -1.25644448
'''
mol.basis = 'aug-cc-pVDZ'
mol.charge = 0
mol.spin = 2
mol.verbose = 4
mol.build(parse_arg=False)
mf = dft.ROKS(mol)
mf.xc = 'bhandhlyp'
mf.grids.atom_grid = (99,590)
mf.max_cycle = 128
mf.max_memory = 128000 #MB
old_e = mf.kernel()
mo = mf.stability()[0]
dm = mf.make_rdm1(mo, mf.mo_occ)
mf.kernel(dm0=dm)
mf.stability()
fchk(mf, 'high_spin.fch', density=True)Submit the PySCF job
python test.py >test.out 2>&1Here fchk() is a module in the open-source package MOKIT. To run this example, you need to install PySCF and MOKIT (which can both be installed via `conda install`).
Step 2. transfer molecular orbitals (MO) and generate input files
After the PySCF job is accomplished, one obtains the wave function file high_spin.fch. Now run the following command
fch2inp high_spin.fch -mrsfOne obtains the file high_spin.inp, which contains MRSF-TDDFT keywords, Cartesian coordinates, basis set data and converged ROKS MOs.
Step 3. perform the MRSF-TDDFT calculation
Run the following command
/path_to_gamsss/rungms high_spin.inp 00 48 >high_spin.gms 2>&1Here 48 CPU cores are used for parallel computations.
You can use the Python API `lin_comb_two_mo` in MOKIT, which performs the linear combinations of two MOs
new_mo1 = 0.5*sqrt2*(mo1 + mo2)
new_mo2 = 0.5*sqrt2*(mo1 - mo2)
Note that the constant 0.5*sqrt2 is needed to ensure that MOs are still normalized (to 1.0). Here is the Python script
from mokit.lib.gaussian import lin_comb_two_mo
lin_comb_two_mo('polyacene.fch', 30, 31)Here the integers 30,31 are the 31th and 32th MOs, respectively. MOKIT can be easily installed using conda, please see https://gitlab.com/jxzou/mokit
Hi, Bernhard,
(1) The dat2fch, fch2inp, fch2mkl are utilities in the open-source package MOKIT (https://gitlab.com/jxzou/mokit), not in Multiwfn. You can install MOKIT using any of the four options (please see README.md). MOKIT provides dozens of utilities to transfer MOs among quantum chemistry packages (and ORCA/GAMESS are within the scope). Using these utilities, one can save the computational time in different quantum chemistry packages when using the same theoretical method. Besides, MOKIT can setup automatic as well as black-box multireference calculations easily, since it can automatically construct and determine active orbitals.
(2) If you do not have Gaussian or you cannot use Gaussian, you can still use the `dat2fch` utility, but with somewhat new MOKIT version >= v1.2.6rc31. The version of MOKIT can be checked via running `automr --version` after installing MOKIT. If you use conda to install MOKIT now, it is supposed to be >= v1.2.6rc31.
Below I provide two GAMESS .dat files, which can be transformed using `dat2fch`. A corresponding .fch file would be generated from scratch, and thus Gaussian software is not needed.
Example 1. RHF .dat file
dat2fch C4H4_cc-pVDZ_rhf.datExample 2. CASSCF .dat file
dat2fch C4H4_uhf_gvb10_CASSCF.dat -no 16where 16 is the sum of doubly occupied orbitals and active orbitals for C4H4 molecule at CAS(4,4).
With a .fch file at hand, you can further transfer MOs to ORCA/GAMESS/OpenMolcas/Molpro via fch2mkl/fch2inp/fch2inporb/fch2com utilities, etc. Your Firefly DAT file is supposed to be very similar to the .dat file provided above. If there is any tiny difference, I believe that you can add them by yourself.
Thank you. The GAMESS(or Firefly) read or print Cartesian-type MOs no matter when you use Cartesian-type or spherical harmonic basis functions. Therefore, when the spherical harmonic basis functions (ISPHER=1 in GAMESS) is used, there are 6D->5D, 10F->7F (also for G, H, etc) contractions to be performed within GAMESS.
MOKIT can transfer MOs from other programs to ORCA. I'm familiar with GAMESS, but not Firefly. I'll show examples using GAMESS below, which is supposed to work both for GAMESS and Firefly. Please do tell me if there is anything different for Firefly.
Assuming we have a file h2o.gjf, it can be a RHF/ROHF/UHF/CASSCF job, e.g.
%chk=h2o.chk
%mem=4GB
%nprocshared=2
#p RHF/6-31G(d,p) 5D 7F nosymm int=nobasistransform
title
0 1
O 0.00000000 0.00000000 0.06200700
H 0.00000000 -0.78397600 -0.49205200
H 0.00000000 0.78397600 -0.49205200Here the keywords `5D 7F` are written explicitly to specify that spherical harmonic basis functions would be used. After this Gaussian job is accomplished, we have the file h2o.chk, now run
formchk h2o.chk h2o.fch
fch2inp h2o.fchto obtain h2o.inp, which is a GAMESS/Firefly input file. You can open this file and modify keywords to suit your target calculations. There is no need to modify Cartesian coordinates or basis set data. Now run the GAMESS job, for example
rungms h2o.inp 00 16 >h2o.gms 2>&1After the GAMESS job is accomplished, one obtains the file h2o.dat, which contains basis set data and MO coefficients (more digits than those coefficients in output file). Now run
dat2fch h2o.dat h2o.fchRemember that we performed a Gaussian job at first, so we already a h2o.fch file. Here the updated MOs are written into the file h2o.fch. Now transfer MOs to ORCA, i.e.
fch2mkl h2o.fch
orca_2mkl h2o_o -gbwThis will lead to 3 files: h2o_o.inp, h2o_o.gbw, h2o_o.mkl. Again, you can open h2o_o.inp and modify keywords to suit your target calculations. For wave function methods like HF/CASSCF, the SCF in different programs can be converged in 1~3 cycles since converged MOs are imported.
Why we need a h2o.fch file at first? This is because the file h2o.dat would not include any basis set data if a built-in basis set in GAMESS is used, which is not possible for transferring MOs to ORCA. But if we use h2o.inp generated by the fch2inp utility, both h2o.inp and h2o.dat includes all basis set data, and the data are exactly in accord with that in h2o.fch. In such case, MOs under 6D/10F/15G/21H can be correctly recognized and contracted to those under 5D. Finally, fch2mkl is used to generate h2o_o.inp and h2o_o.mkl files from h2o.fch.
Please do not hesitate to ask related questions if you encounter any problem.
Hi, now you can use the utility `molden2fch` in MOKIT to generate a Gaussian .fch file. And then you can load the .fch file in Multiwfn. Assuming you have the file h2o.molden generated by Turbomole, you can run the following Shell command
```
molden2fch h2o.molden -tm
```
and the file h2o.fch is generated. Here `-tm` tells the utility that this is a Turbomole-type .molden file. RHF/ROHF/UHF wave function and DFT counterparts are supported. Note that currently only the all-electron basis set is supported for molden2fch, since there is no ECP/PP information in .molden file.
Please note that (un)relaxed density of CCSD(T) in PySCF are problematic currently. The problem occurs at the (T) step, while the CCSD density is correct. See the PySCF github issue https://github.com/pyscf/pyscf/issues/1272.
My personal recommendation is to use Molpro or PSI4. Also note that CCSD(T) density is not supported in ORCA (so far for all 5.x).
Pages: 1