Output Formats Guide

This guide covers all supported output formats for exporting fragments to quantum chemistry programs.

Supported Programs

Program	Format	Features
GAMESS	FMO/EFMO/EFP	Full fragment support
Psi4	SAPT/MBE	Interaction energies
Q-Chem	EFP/XSAPT	Embedding
ORCA	Multi-job	Fragment calculations
NWChem	BSSE	Counterpoise
Molpro	SAPT/LMP2	Fragment calculations
Turbomole	Fragment	Coordinate export
CFOUR	Fragment	ZMAT export
Generic	XYZ/PDB	Structure only

GAMESS

Standard FMO

from autofragment.io import write_gamess_fmo

write_gamess_fmo(
    fragments,
    "output.inp",
    method="MP2",
    basis="6-31G*",
    runtyp="ENERGY",
    memory=800
)

EFMO (Effective Fragment Molecular Orbital)

from autofragment.io import write_gamess_efmo

write_gamess_efmo(
    fragments,
    "efmo.inp",
    method="MP2",
    basis="6-31G*"
)

FMO Options

Option	Description
`nbody`	MBE order (2 or 3)
`resppc`	ESP pair approximation
`resdim`	Distance threshold for ESP
`runtyp`	ENERGY, GRADIENT, HESSIAN

Psi4

Basic Output

from autofragment.io import write_psi4_fragment

write_psi4_fragment(
    fragments,
    "psi4_input.dat",
    method="B3LYP",
    basis="cc-pVDZ",
    extra_options={"reference": "rhf"}
)

SAPT Calculations

from autofragment.io import write_psi4_sapt

write_psi4_sapt(
    [frag_a, frag_b],
    "sapt.dat",
    method="sapt2+",
    basis="aug-cc-pVDZ"
)
# Requires exactly 2 fragments (dimer)

MBE in Psi4

write_psi4_fragment(
    fragments,
    "mbe.dat",
    method="MP2",
    basis="cc-pVDZ",
    runtype="energy"
)

Q-Chem

from autofragment.io import write_qchem_efp

write_qchem_efp(
    fragments,
    "qchem.in",
    method="B3LYP",
    basis="6-31G*",
    qm_fragment_indices=[0],
)

EFP in Q-Chem

from autofragment.io import write_qchem_xsapt

write_qchem_xsapt(
    [frag_a, frag_b],
    "xsapt.in",
    basis="6-31G*",
    xsapt_level="xsapt(ksdft)"
)

ORCA

from autofragment.io import write_orca_multijob

write_orca_multijob(
    fragments,
    "orca_fragments.inp",
    method="B3LYP",
    basis="def2-SVP",
    memory=4000
)

ORCA Options

from autofragment.io import write_orca_fragment

write_orca_fragment(
    fragments,
    "orca_single.inp",
    method="DLPNO-CCSD(T)",
    basis="cc-pVTZ"
)

NWChem

from autofragment.io import write_nwchem_fragment

write_nwchem_fragment(
    fragments,
    "nwchem.nw",
    method="DFT",
    basis="6-31G*",
    extra_options={"xc": "b3lyp"}
)

BSSE Counterpoise

from autofragment.io import write_nwchem_bsse

write_nwchem_bsse(
    [frag_a, frag_b],
    "bsse.nw",
    basis="aug-cc-pVDZ",
    method="mp2"
)

Molpro

from autofragment.io import write_molpro_sapt

write_molpro_sapt([frag_a, frag_b], "molpro.com", basis="aug-cc-pVDZ")

Turbomole

from autofragment.io import write_turbomole_fragment

write_turbomole_fragment(fragments, "coord")

CFOUR

from autofragment.io import write_cfour_fragment

write_cfour_fragment(fragments, "ZMAT")

Generic Formats

XYZ

from autofragment.io import write_xyz_fragments

write_xyz_fragments(fragments, "fragments.xyz")

PDB

from autofragment.io import write_pdb_fragments

write_pdb_fragments(fragments, "fragments.pdb", mode="chains")

JSON (For serialization)

from autofragment.io import write_qcschema, read_qcschema

write_qcschema(system, "fragments.json")

# Load back
system = read_qcschema("fragments.json")

Format Registry

Discover available formats:

from autofragment.io import FormatRegistry

formats = FormatRegistry.supported_formats()
print(formats["write"])

# Get writer function by name
FormatRegistry.write("output.inp", fragments, format="gamess_fmo", method="MP2", basis="6-31G*")

Writer Options

Available options are writer-specific. For example:

from autofragment.io import write_gamess_fmo

write_gamess_fmo(
    fragments,
    "fmo.inp",
    method="MP2",
    basis="6-31G*",
    title="My calc",    # Title/comment
    memory=800,          # Memory request (MW)
)

Batch Writing

Write multiple fragments at once:

from autofragment.io import write_orca_fragment

for i, fragment in enumerate(fragments):
    write_orca_fragment([fragment], f"outputs/frag_{i}.inp")

Custom Writers

Create custom output format:

from pathlib import Path
from autofragment.io import FormatRegistry

def write_plain_xyz_fragments(fragments, filepath):
    out = Path(filepath)
    out.parent.mkdir(parents=True, exist_ok=True)
    with out.open("w") as handle:
        for fragment in fragments:
            handle.write(f"# {fragment.id}\n")
            coords = fragment.get_coords()
            for i, symbol in enumerate(fragment.symbols):
                x, y, z = coords[i]
                handle.write(f"{symbol} {x:.6f} {y:.6f} {z:.6f}\n")

FormatRegistry.register_writer("plain_xyz_fragments", write_plain_xyz_fragments, extensions=[".pxyz"])