Moving from ORCA¶

vibe-qc’s molecular SCF stack validates against ORCA 6.1.1 for parity at the 0.13 mHa level on glycine / def2-TZVP / RIJCOSX (see tutorial 31). The chemistry maps cleanly; the input idiom is different — ORCA takes a keyword-driven plain-text deck while vibe-qc takes a Python script. This page is a side-by-side crosswalk.

For users coming from PySCF instead, see from_pyscf. For CRYSTAL users, see from_crystal.

Input file shape ¶

ORCA `.inp`¶

! RKS PBE0 D3BJ DEF2-TZVP RIJCOSX TIGHTSCF OPT

%scf
  MaxIter 200
  KDIIS true
  CNVDIIS 1.0e-7
end

%pal
  nprocs 4
end

* xyz 0 1
O      0.000000   0.000000   0.117790
H      0.000000   0.755453  -0.471160
H      0.000000  -0.755453  -0.471160
*

vibe-qc Python ¶

import vibeqc as vq

mol = vq.Molecule.from_xyz("h2o.xyz")          # Å in file, bohr internal

vq.run_job(
    mol,
    method="rks",
    functional="PBE0",
    basis="def2-tzvp",
    dispersion="d3bj",                          # D3BJ keyword
    density_fit=True, cosx=True,                # RIJCOSX
    optimize=True,                              # OPT
    num_threads=4,                              # %pal nprocs 4
    output="output-h2o-pbe0",
    options=vq.RKSOptions(
        max_iter=200,
        scf_accelerator=vq.SCFAccelerator.KDIIS,  # KDIIS
        conv_tol_energy=1e-9,                   # ~ TIGHTSCF
    ),
)

ORCA’s compact ! keyword line trades concision for grammar constraints (every keyword has to be recognised by the parser). vibe-qc’s Python input trades concision for sweep-friendliness — the same script can loop over functionals / basis sets in plain Python without a templating layer.

Keyword crosswalk ¶

Method + basis (the `!` line)¶

ORCA	vibe-qc
`! HF`	`method="rhf"` (or `"uhf"` for open-shell)
`! RKS PBE0`	`method="rks"`, `functional="PBE0"`
`! UKS B3LYP`	`method="uks"`, `functional="B3LYP"`
`! MP2`	`method="rmp2"` (after `run_rhf`); also `run_mp2(...)` directly
`! RI-MP2`	Same plus `density_fit=True, aux_basis="def2-tzvp-rifit"`
`! B2PLYP`	`method="rks", functional="B2PLYP"` via `run_b2plyp(...)`
`! DEF2-TZVP`	`basis="def2-tzvp"`
`! 6-31G*`	`basis="6-31g*"`
`! CC-PVDZ`	`basis="cc-pvdz"`
`! ANO-RCC`	`basis="ano-rcc"`
`! RIJCOSX`	`density_fit=True, cosx=True`
`! RIJK`	`density_fit=True, cosx=False`
`! D3BJ`	`dispersion="d3bj"`
`! D4`	`dispersion="d4"`
`! TIGHTSCF`	`opts.conv_tol_energy = 1e-9` (vibe-qc’s default is already 1e-8 — TIGHTSCF is the next step)
`! VERYTIGHTSCF`	`opts.conv_tol_energy = 1e-10`
`! OPT`	`run_job(..., optimize=True)`
`! FREQ`	`run_job(..., compute_hessian=True, mode="finite-diff")` (analytic Hessian roadmap)
`! NORMALPRINT / MINIPRINT / NORMALPRINT`	`verbose=` kwarg on `run_job` (PySCF-convention 0-6 levels — see output_files § Verbosity)
`! NOITER`	Not a separate flag — set `opts.max_iter = 0` if you really want zero SCF iterations

Important

B3LYP convention. vibe-qc and ORCA both default to VWN5 B3LYP (libxc id 475) as of v0.8.0 — the two now agree to <1 mHa on glycine. PySCF defaults to VWN3 (libxc id 402) — that’s the B3LYP/G variant in both vibe-qc and ORCA notation. Pass functional="b3lyp/g" if you need the VWN3 form.

`%scf` block ¶

ORCA `%scf`	vibe-qc
`MaxIter n`	`opts.max_iter = n`
`ConvForced 1` (force run despite non-convergence)	(vibe-qc returns a result object with `converged = False` either way)
`CNVDIIS n` (DIIS error threshold)	`opts.conv_tol_grad = n`
`DIIS true/false`	`opts.scf_accelerator = vq.SCFAccelerator.DIIS` / `.EDIIS_DIIS`
`KDIIS true` (ORCA’s strict-convergence default)	`opts.scf_accelerator = vq.SCFAccelerator.KDIIS`
`SOSCF true`	`opts.soscf_threshold = 1.0` (with `opts.soscf_opts.trust_radius = ...`)
`Damp DampFac p / DampErr e`	`opts.damping = p`; the error-driven damping isn’t yet exposed
`Shift Shift n` (level shift in eV)	`opts.level_shift = n / 27.2114` (Hartree)
`Guess HCore / PModel / PAtom / Hueckel / Read`	`opts.initial_guess = vq.InitialGuess.HCORE / SAD / PATOM / HUECKEL / READ`
`BrokenSym n1 n2`	Manual SAD with custom multiplicity per fragment + MOM (Phase 17h). Not a one-liner today.
`STABPerform true` (Hessian stability check)	Not yet implemented
`SCFConvForced 1`	Force `result.converged = False` paths to still return a result — vibe-qc always returns the result + `converged` flag.

`%basis` block ¶

ORCA `%basis`	vibe-qc
`NewGTO 78 "LANL2DZ" end` (per-element basis override)	Use a `basis_library/custom/*.g94` file; vibe-qc applies it per element. See basis_sets § Custom basis sets.
`NewECP 78 "LANL2DZ" end`	`opts.ecp_centers = [vq.ECPCenter(Z=78, xyz=...)]` + `opts.ecp_library = "lanl2dz"`
`Aux "def2/J"`	`opts.aux_basis = "def2-universal-jkfit"`
`AuxJ "def2-svp/J"` / `AuxC "cc-pVDZ/C"`	`opts.aux_basis_j` / `opts.aux_basis_c` (these split-aux fields are roadmap; today `aux_basis` is the single field)

`%method` block ¶

ORCA `%method`	vibe-qc
`Functional B3LYP`	`opts.functional = "B3LYP"` (or in `run_job(functional="B3LYP")`)
`Method DFT`	implicit by calling `run_rks` / `run_uks`
`RI on`	`opts.density_fit = True`
`RunTyp Energy / Gradient / Opt / Freq`	call `run_job(optimize=True)` / `run_job(compute_hessian=True)` / `compute_gradient_rhf(...)` etc. directly

`%pal` block ¶

ORCA `%pal`	vibe-qc
`nprocs n`	`num_threads=n` on `run_job`, or `OMP_NUM_THREADS=n` env var. vibe-qc is OpenMP (shared-memory), not MPI. Single-node only.

`%output` block ¶

ORCA `%output`	vibe-qc
`Print[ P_MOs ] 1` (print orbitals to .out)	Default — vibe-qc always prints the orbital table (up to `opts.n_virtual = 5`).
`Print[ P_OverlapM ] 1` (print overlap matrix)	Not directly — `result.overlap` is the NumPy array for programmatic access.
`XYZFile true`	Always-on as of v0.8.x. The final geometry lands in `{stem}.xyz`.
`MOPrintLimit 0.001`	`opts.n_virtual = N` controls how many virtuals appear in the orbital table.
`MullikenPop true`	Default — vibe-qc always reports Mulliken + Löwdin + Mayer in the post-SCF properties block. See properties.

RIJCOSX in detail ¶

ORCA’s flagship hybrid-DFT recipe is !PBE0 D3BJ DEF2-TZVP RIJCOSX TIGHTSCF. The vibe-qc equivalent is:

opts = vq.RKSOptions()
opts.functional   = "PBE0"
opts.dispersion   = "d3bj"
opts.density_fit  = True
opts.cosx         = True
opts.aux_basis    = "def2-tzvp-jk"     # default; auto-picked by basis name
opts.cosx_grid    = vq.default_cosx_grid_options()  # = ORCA's default GridX
opts.conv_tol_energy = 1e-9             # TIGHTSCF

The RIJCOSX SCF + analytic gradient match ORCA’s to 0.13 mHa on glycine / def2-TZVP per tutorial 31.

ECPs ¶

ORCA’s ! DEF2-TZVP automatically loads the matching ECPs for heavy atoms. vibe-qc keeps the orbital basis and the ECP as two separate fields so you can mix-and-match (e.g. def2-TZVP orbital with ecp46mdf if you want the Stuttgart MDF instead of the def2-bundled SDD). The basissetdev-conditional vq.auto_ecp_centers(mol, basis_name) helper closes the gap once that branch merges:

# Manual recipe (always works):
opts.ecp_centers = [
    vq.ECPCenter(Z=78, xyz=[0.0, 0.0, 0.0]),
]
opts.ecp_library = "ecp46mdf"   # or "lanl2dz" for HW pseudopotential

# Auto recipe (basissetdev branch only):
opts.ecp_centers, opts.ecp_library = vq.auto_ecp_centers(mol, "def2-tzvp")

See ecp and tutorial 32.

What ORCA does that vibe-qc doesn’t (yet)¶

Use ORCA for these for now:

Coupled-cluster (CCSD, CCSD(T), DLPNO-CCSD(T)). vibe-qc tops out at MP2.
MR-CI / CASSCF / NEVPT2. Multi-reference is not on the vibe-qc roadmap below v2.x.
TD-DFT and excited states. Roadmap (rough sketch in docs/roadmap.md).
Range-separated hybrids (ωB97X-D3, ωB97M-V, HSE06, CAM-B3LYP). The libxc ids resolve but the RSH machinery for periodic K is not yet wired.
Meta-GGAs (M06-2X, r²SCAN, MN15-L). Queued.
Composite “3c” methods (r²SCAN-3c, ωB97X-3c, B97-3c). Basis carriers ship; gCP machinery doesn’t yet.
Periodic SCF in ORCA-style. ORCA does molecular only — but if you’re moving from ORCA to do solids, vibe-qc’s periodic stack is what you want (see periodic_systems).

What vibe-qc does that ORCA doesn’t (or does differently)¶

Things you gain by switching:

Auto-citations. Every job writes a .bibtex / .references pair; ORCA prints the citation list to the .out but doesn’t give you the BibTeX file. See citations.
Python scripting. Sweep over functionals / basis / k-mesh in a for loop, not by maintaining N input files. The PySCF guide elaborates on the workflow shape.
Periodic SCF. ORCA is molecular only; vibe-qc has 1D / 2D / 3D periodic HF and KS-DFT today.
MPL-2.0 license. Drop into any project, including closed-source software.
vq queue. Submit jobs to a remote box with a vibe-qc-aware preflight; ORCA users typically run on SLURM/PBS via sbatch. See tutorial 43.
Pre-flight memory estimator. Aborts before the SCF starts if the dense-ERI / DFT-grid / MP2 working set exceeds available RAM. See memory.

Validating vibe-qc against ORCA ¶

ORCA is the cross-validation reference for vibe-qc’s molecular hybrid-DFT + RIJCOSX surface. The parity_matrix_orca/ suite runs the same Atoms through vibe-qc and out-of-process ORCA, parses both .out files, and produces a side-by-side comparison artefact.

Quick parity check on your own system:

# 1. Run in ORCA:
orca my-input.inp > my-input.orca.out

# 2. Run in vibe-qc:
python my-input.py            # writes my-input.out / .bibtex / etc.

# 3. Compare the two total energies:
grep "FINAL SINGLE POINT ENERGY" my-input.orca.out
grep "Total energy:" my-input.out

Expected agreement after the v0.8.0 B3LYP-convention alignment: ~µHa per atom for closed-shell HF / DFT; ~0.13 mHa per atom for RIJCOSX hybrids; ~10 µHa per atom for D3(BJ) corrections (the dispersion is bit-identical because both codes use Grimme’s reference implementation).