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" (same VWN5 flavor in both codes — see the B3LYP-convention box below)

! 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 mean the VWN5 flavor by the bare name (libxc id 475) — bare B3LYP matches across the two codes with no translation, and the keyword pairs mirror each other exactly:

  • ORCA ! B3LYP ↔ vibe-qc functional="b3lyp" (explicit spelling: "b3lyp5").

  • ORCA ! B3LYP/G ↔ vibe-qc functional="b3lyp/g" (PySCF-style spelling: "b3lypg") — the Gaussian / VWN-RPA flavor, ~10–15 mHa per heavy atom apart from the default.

Measured on H₂/STO-3G at 1.4 bohr: ORCA B3LYP −1.158669 vs vibe-qc b3lyp −1.1586001; ORCA B3LYP/G −1.165470 vs vibe-qc b3lyp/g −1.1654009 (ORCA DefGrid2 accounts for the ~µHa residual). See functionals.md § B3LYP.

%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" (same flavor in both codes; see the B3LYP-convention box above)

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. Production parallelism is OpenMP (shared-memory, single node). The optional [mpi] extra (v0.12.0, mpi4py) adds distributed-memory shell-pair distribution and k-point / state task farming; the GPW grid overlay is experimental — see features.

%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 (DLPNO-CCSD(T)). vibe-qc ships an in-tree canonical CCSD foundation but the production DLPNO acceleration is roadmap. For DLPNO today, use ORCA.

  • MR-CI / CASSCF / NEVPT2. Multi-reference perturbation theory is not on the vibe-qc roadmap below v2.x. The v0.9.0 wavefunction-methods stack (Selected CI, DMRG, v2RDM) covers the static-correlation cases CASSCF would, but only on the Hamiltonian level (no CASPT2 / NEVPT2 follow-up).

  • TD-DFT and excited states. Roadmap (rough sketch in docs/roadmap.md).

  • Range-separated hybrids beyond ωB97X / ωB97X-D. vibe-qc v0.9.0 ships ωB97X and ωB97X-D (the latter via vibeqc.run_wb97x_d + the CHG dispersion kernel); ωB97M-V / ωB97X-V need the VV10 non-local-correlation functional and are queued, HSE06 / CAM-B3LYP need the RSH machinery for periodic K and are also queued.

  • Meta-GGAs (some). TPSS, TPSSh, M06-L, M06-2X, SCAN, and r²SCAN ship in v0.9.0 with τ-density analytic gradients; MN15-L and similar are queued.

  • Composite “3c” methods. The 3c family (HF-3c, PBEh-3c, r²SCAN-3c, B97-3c, ωB97X-3c) ships in v0.9.0 via method="hf-3c" etc., with gCP and D3 / D4 wired through the molecular runner. ORCA’s reference numbers match.

  • 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 48.

  • 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).

See also