### Install ORCA-Parser with pip

Source: https://github.com/avanteijlingen/orca_parser/blob/main/PyPi.md

Installs the ORCA-Parser Python module using pip. This is the primary method for adding the library to your Python environment. Ensure you have pip installed and accessible.

```bash
pip install orca-parser
```

--------------------------------

### Extract Input Parameters and Computational Details with ORCAParse

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Extracts the functional, basis set, solvation model, and other computational parameters from the output file header of an ORCA calculation. The `parse_input()` method returns a dictionary containing details such as job type, charge, multiplicity, dispersion corrections, and ORCA version. This is useful for understanding the setup of a specific calculation.

```python
import orca_parser

calculation = orca_parser.ORCAParse("dft_calculation.out")

# Parse input configuration
input_details = calculation.parse_input()

print("Functional:", input_details['Functional'])
print("Basis set:", input_details['BasisSet'])
print("Job type:", input_details['Job'])  # OPT or SP
print("Charge:", input_details['Charge'])
print("Multiplicity:", input_details['Multiplicity'])
print("Solvation:", input_details['Solvation'])
print("Dispersion correction:", input_details.get('Dispersion'))
print("ORCA version:", input_details['version'])
print("Frequency calculation:", input_details['Freq'])
print("RIJCOSX approximation:", input_details['RIJCOSX'])
print("UKS (unrestricted):", input_details['UKS'])
```

--------------------------------

### Basic Usage of ORCAParse

Source: https://github.com/avanteijlingen/orca_parser/blob/main/PyPi.md

Demonstrates the basic usage of the ORCAParse class to read and extract information from an ORCA output file. It shows how to check for job validity, retrieve execution time, parse input lines, and extract atomic coordinates. Dependencies include the orca_parser library itself.

```python
import orca_parser
Optimization = orca_parser.ORCAParse("Test-cases/Phenol/Opt.out")

print("ORCA exited normally:", Optimization.valid)
print("Job took:", Optimization.seconds(), "seconds")
print("Job input line:", Optimization.parse_input())

Optimization.parse_coords()
print("Atoms:", Optimization.atoms)
print("Final coordinates:")
print(Optimization.coords[-1])
```

--------------------------------

### Parse Gaussian 16 Output Files

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Parses Gaussian 16 output files to extract various computational data, including energies, coordinates, forces, and thermodynamic properties. Supports optimization, IRC, and single-point calculations. Outputs trajectory files using ASE. Requires numpy for force calculations.

```python
import orca_parser
import numpy as np
from ase import Atoms

# Parse Gaussian output
calculation = orca_parser.GaussianParse("gaussian_opt.log", verbose=True)

# Check validity
print("Valid output:", calculation.valid)

# Parse input details
input_info = calculation.parse_input()
print("Job type:", input_info['Job'])  # OPT, IRC, or SP
print("Functional:", input_info['Functional'])
print("Basis set:", input_info['BasisSet'])
print("Solvent:", input_info['Solvation'])
print("Charge:", input_info['Charge'])
print("Multiplicity:", input_info['Multiplicity'])
print("Gaussian version:", input_info['version'])

# Parse molecular data
calculation.parse_coords()
calculation.parse_energies()
print("Number of geometries:", calculation.coords.shape[0])
print("Number of atoms:", len(calculation.atoms))
print("Atoms:", calculation.atoms)
print("Final energy (Eh):", calculation.energies[-1])

# Parse forces if available
calculation.parse_forces()
if hasattr(calculation, 'forces') and len(calculation.forces) > 0:
    print("Forces shape:", calculation.forces.shape)
    print("Final RMS force:", np.sqrt(np.mean(calculation.forces[-1]**2)))

# Parse thermodynamic data
calculation.parse_free_energy()
if hasattr(calculation, 'Gibbs'):
    print(f"Gibbs free energy: {calculation.Gibbs:.6f} Eh")

# Write trajectory
for i in range(calculation.coords.shape[0]):
    mol = Atoms(calculation.atoms, calculation.coords[i])
    mol.write("gaussian_trajectory.xyz", append=(i > 0))
```

--------------------------------

### Parse NWChem Output Files

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Parses NWChem 7+ output files, automatically detecting whether the calculation was an optimization or a single-point energy calculation. The parser extracts fundamental calculation information and prepares the object for further data retrieval.

```python
import orca_parser

# Parse NWChem output
calculation = orca_parser.NWChemParse("nwchem_calculation.nwout", verbose=True)
```

--------------------------------

### Measure Bond Distances During Optimization with orca_parser

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This Python code snippet illustrates how to measure and track specific bond distances throughout a geometry optimization or scan calculation using the orca_parser library. It parses an optimization output file, measures a specified bond distance, and plots its evolution over the calculation steps.

```python
import orca_parser
import matplotlib.pyplot as plt

# Parse optimization
calculation = orca_parser.ORCAParse("optimization.out")
calculation.parse_coords()
calculation.parse_energies()

# Measure bond distance between atoms 0 and 5
distances = calculation.scan_bond(a0=0, a1=5)

print(f"Initial bond length: {distances[0]:.4f} Å")
print(f"Final bond length: {distances[-1]:.4f} Å")
print(f"Change: {distances[-1] - distances[0]:+.4f} Å")

# Plot bond distance evolution
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8), sharex=True)

# Bond distance
ax1.plot(distances, 'o-', color='blue')
ax1.set_ylabel('Bond Distance (Å)')
ax1.grid(True, alpha=0.3)
ax1.set_title(f'Bond {calculation.atoms[0]}{0}-{calculation.atoms[5]}{5}')
```

--------------------------------

### Track Orbital Energies During Optimization (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This snippet visualizes the evolution of HOMO and LUMO orbital energies throughout an optimization process. It requires access to the calculation's 'all_HOMO' and 'all_LUMO' attributes and uses matplotlib for plotting.

```python
import matplotlib.pyplot as plt

homo_energies = [step[2] for step in calculation.all_HOMO]
lumo_energies = [step[2] for step in calculation.all_LUMO]
plt.plot(homo_energies, label='HOMO')
plt.plot(lumo_energies, label='LUMO')
plt.xlabel('Optimization step')
plt.ylabel('Energy (eV)')
plt.legend()
plt.savefig('orbital_evolution.png')
```

--------------------------------

### Parse Forces from Geometry Optimization (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This snippet shows how to extract Cartesian gradients (forces) for each step of a geometry optimization from an ORCA output file. It uses the orca_parser library and numpy, and matplotlib for plotting the RMS and maximum forces against optimization cycles. Forces are parsed as part of the `parse_free_energy` method.

```python
import orca_parser
import numpy as np
import matplotlib.pyplot as plt

calculation = orca_parser.ORCAParse("optimization.out")
calculation.parse_free_energy()  # Forces are parsed as part of free energy

# Access forces for each optimization cycle
for cycle, force_array in calculation.forces.items():
    print(f"Cycle {cycle}: shape {force_array.shape}")
    rms_force = np.sqrt(np.mean(force_array**2))
    max_force = np.max(np.abs(force_array))
    print(f"  RMS force: {rms_force:.6f} Eh/Bohr")
    print(f"  Max force: {max_force:.6f} Eh/Bohr")

# Plot force convergence
cycles = sorted(calculation.forces.keys())
rms_forces = [np.sqrt(np.mean(calculation.forces[c]**2)) for c in cycles]
max_forces = [np.max(np.abs(calculation.forces[c])) for c in cycles]

plt.figure(figsize=(10, 6))
plt.semilogy(cycles, rms_forces, 'o-', label='RMS Force')
plt.semilogy(cycles, max_forces, 's-', label='Max Force')
plt.axhline(y=3e-4, color='r', linestyle='--', label='Convergence threshold')
plt.xlabel('Optimization cycle')
plt.ylabel('Force (Eh/Bohr)')
plt.legend()
plt.grid(True, which='both', alpha=0.3)
plt.savefig('force_convergence.png')
```

--------------------------------

### Write ORCA Normal Modes to XYZ

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Writes multiple normal modes from an ORCA Hessian calculation to separate XYZ files. Each file contains coordinates for a specific vibrational mode, allowing for visualization of molecular motion. Requires a Hessian object with IR frequency and intensity data.

```python
for mode_num in range(6, 15):  # First 9 real vibrational modes
    freq = hessian.IR.loc[mode_num-6, 'wavenumber']
    intensity = hessian.IR.loc[mode_num-6, 'Int']
    filename = f"mode_{mode_num}_{freq:.0f}cm.xyz"
    hessian.WriteMode(filename, mode=mode_num, steps=15, amplitude=0.8)
    print(f"Written {filename} (ν={freq:.1f} cm⁻¹, I={intensity:.1f})")

# Access raw normal mode vectors
mode_7_vector = hessian.normalmodes[7]  # Returns pandas Series
print("Mode 7 displacement vector:", mode_7_vector.values.reshape(-1, 3))
```

--------------------------------

### Parse Hessian Files and Normal Modes (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This code uses the HessianTools class from orca_parser to read ORCA .hess files. It allows access to molecular data, IR spectrum information (wavenumber, extinction coefficient, intensity, etc.), and provides functionality to write animated .xyz trajectories for specific normal modes.

```python
import orca_parser

# Parse Hessian file
hessian = orca_parser.HessianTools("molecule.hess")

# Access molecular data
print("Atoms:", hessian.atoms)
print("Coordinates (Å):", hessian.positions)
print("Number of normal modes:", hessian.Nnormalmodes)

# Access IR spectrum from Hessian
print(hessian.IR)
# Columns: wavenumber (cm⁻¹), eps, Int, TX, TY, TZ

# Write animated normal mode trajectory
# Mode 6 is typically the first real vibrational mode (after 6 translations/rotations)
hessian.WriteMode("mode_6.xyz", mode=6, steps=20, amplitude=0.5)
hessian.WriteMode("mode_10.xyz", mode=10, steps=30, amplitude=1.0)
```

--------------------------------

### Parse ORCA Relaxed Surface Scan Files

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Parses ORCA relaxed surface scan output files to extract coordinates and energies for potential energy surface analysis. Supports plotting the energy profile and saving the trajectory using ASE. Energies are converted to kcal/mol relative to the minimum energy.

```python
import orca_parser
import matplotlib.pyplot as plt
import numpy as np
from ase import Atoms

# Parse surface scan output
scan = orca_parser.parse_scan("surface_scan.out")

# Extract scan data
scan.parse_scan_coords()
scan.parse_scan_energies()

print("Scan atoms:", scan.scan_atoms)
print("Number of scan points:", len(scan.scan_coords))
print("Number of energies:", len(scan.scan_energies))
print("Scan coordinates shape:", scan.scan_coords.shape)

# Convert energies to relative energies (kcal/mol)
energies_hartree = np.array(scan.scan_energies)
relative_energies = (energies_hartree - energies_hartree.min()) * 627.509  # Eh to kcal/mol

# Calculate bond distance along scan coordinate (example: atoms 0-1)
distances = []
for frame in scan.scan_coords:
    bond_vector = frame[1] - frame[0]
    distance = np.linalg.norm(bond_vector)
    distances.append(distance)

# Plot potential energy surface
plt.figure(figsize=(10, 6))
plt.plot(distances, relative_energies, 'o-', linewidth=2, markersize=8)
plt.xlabel('Bond Distance (Å)')
plt.ylabel('Relative Energy (kcal/mol)')
plt.title('Relaxed Surface Scan')
plt.grid(True, alpha=0.3)
plt.savefig('surface_scan.png', dpi=300)

# Save scan trajectory
for i, coords in enumerate(scan.scan_coords):
    mol = Atoms(scan.scan_atoms, coords)
    mol.write("scan_trajectory.xyz", append=(i > 0))

print(f"Energy barrier: {relative_energies.max():.2f} kcal/mol")
print(f"Minimum at step {relative_energies.argmin()}")
```

--------------------------------

### Access ORCA Calculation Results

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This snippet demonstrates how to access various properties of an ORCA calculation after parsing. It covers calculation status, molecular data, computational details, and structured data. It also shows how to write structures to an XYZ file and access the final ASE molecule object.

```python
from ase import Atoms

# Assuming 'calculation' is an already parsed ORCA calculation object

# Check calculation status
print("Valid output:", calculation.valid)
print("Clean termination:", calculation.clean_stop)

# Parse all data using the unified .parse() method
calculation.parse()

# Access molecular data
print("Atoms:", calculation.atoms)
print("Net charge:", calculation.net_charge)
print("Multiplicity:", calculation.multiplicity)
print("Coordinates shape:", calculation.coords.shape)
print("Energies:", calculation.energies)

# Check computational details
print("Functional:", calculation.functional)
print("Organic basis set:", calculation.orgBasis)
print("Metal basis set:", calculation.RaBasis)
print("SMD solvation:", calculation.SMD)

# Access COSMO solvation energies if present
if hasattr(calculation, 'cosmo_energies'):
    print("COSMO energies:", calculation.cosmo_energies)

# Get structured data dictionary
data = calculation.get_data()
print("Calculation metadata:", data)
# Returns: {'charge': 0, 'multiplicity': 1, 'SMD': False,
#           'functional': 'PBE0', 'orgBasis': 'def2-TZVPP',
#           'RaBasis': 'crenbl_ecp'}

# Write structures
for i, coords in enumerate(calculation.coords):
    mol = Atoms(calculation.atoms, coords)
    mol.write("nwchem_structures.xyz", append=(i > 0))

# Access ASE molecule for last frame
final_molecule = calculation.asemol
final_molecule.write("final_structure.xyz")
```

--------------------------------

### Parse ORCA Engrad Files

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Parses ORCA .engrad files to extract molecular information such as the number of atoms, energy, atomic numbers, coordinates, and forces. Outputs are in atomic units (Eh and Bohr). Optionally converts coordinates to Ångströms and calculates force metrics. Integrates with ASE for structure creation.

```python
import orca_parser
import numpy as np
from ase import Atoms

# Parse engrad file
natoms, energy, atomic_numbers, coords, forces = orca_parser.parse_engrad("molecule.engrad")

print(f"Number of atoms: {natoms}")
print(f"Energy: {energy:.6f} Eh")
print(f"Atomic numbers: {atomic_numbers}")
print(f"Coordinates (Bohr):\n{coords}")
print(f"Forces (Eh/Bohr):\n{forces}")

# Convert to Ångströms
coords_angstrom = coords * 0.52917724900001
print(f"Coordinates (Å):\n{coords_angstrom}")

# Calculate RMS and max force
rms_force = np.sqrt(np.mean(forces**2))
max_force = np.max(np.abs(forces))
print(f"RMS force: {rms_force:.6f} Eh/Bohr")
print(f"Max force: {max_force:.6f} Eh/Bohr")

# Create ASE atoms object
atoms = Atoms(numbers=atomic_numbers, positions=coords_angstrom)
atoms.write("structure_from_engrad.xyz")
```

--------------------------------

### Parse ORCA Output File with ORCAParse

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Reads and validates ORCA output files, extracting energies, coordinates, spectra, and thermodynamic data. It supports single point, optimization, and frequency calculations. The parser returns a Calculation object with attributes for job validity, convergence status, molecular structures, energies, and thermodynamic properties. It can also convert the molecular structure to an ASE Atoms object.

```python
import orca_parser

# Parse an ORCA optimization output
calculation = orca_parser.ORCAParse("phenol_optimization.out")

# Check if job terminated normally
print("Valid calculation:", calculation.valid)
print("Converged:", calculation.CONVERGED)

# Parse all available data
calculation.parse()

# Access molecular structure
print("Atoms:", calculation.atoms)
print("Final coordinates (Å):", calculation.coords[-1])
print("Number of geometries:", calculation.coords.shape[0])

# Access energies
print("Final energy (Eh):", calculation.energies[-1])
print("All energies:", calculation.energies)

# Access thermodynamic properties
if hasattr(calculation, 'Gibbs'):
    print("Gibbs free energy (Eh):", calculation.Gibbs)
    print("All Gibbs energies:", calculation.AllGibbs)
    print("Vibrational frequencies (cm⁻¹):", calculation.frequencies)

# Get computation time
print("Runtime (seconds):", calculation.seconds())

# Convert to ASE Atoms object
molecule = calculation.asemol
molecule.write("output.xyz")
```

--------------------------------

### Parse TDDFT Absorption and CD Spectra (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This code extracts UV-Vis absorption spectra (wavelengths and oscillator strengths) and Circular Dichroism (CD) data from ORCA TDDFT calculations. It uses the orca_parser library and numpy for data manipulation, and matplotlib for plotting the broadened absorption spectrum. The function 'gaussian_broaden' is included for spectral convolution.

```python
import orca_parser
import numpy as np
import matplotlib.pyplot as plt

calculation = orca_parser.ORCAParse("tddft_calculation.out")
calculation.parse_absorption()

# Access wavelengths and oscillator strengths
print("Wavelengths (nm):", calculation.wavelengths)
print("Oscillator strengths:", calculation.fosc)

# Find maximum absorption
max_idx = np.argmax(calculation.fosc)
print(f"λmax: {calculation.wavelengths[max_idx]:.1f} nm (f={calculation.fosc[max_idx]:.4f})")

# Parse circular dichroism if available
if "CD SPECTRUM" in calculation.raw:
    calculation.parse_CD()
    print("CD wavelengths (nm):", calculation.CD)
    print("Rotatory strengths:", calculation.R)

# Generate broadened spectrum with Gaussian convolution
def gaussian_broaden(wavelengths, intensities, x_range, fwhm=20):
    sigma = fwhm / (2 * np.sqrt(2 * np.log(2)))
    spectrum = np.zeros_like(x_range)
    for wl, intensity in zip(wavelengths, intensities):
        spectrum += intensity * np.exp(-((x_range - wl)**2) / (2 * sigma**2))
    return spectrum

x = np.linspace(200, 800, 1000)
y = gaussian_broaden(calculation.wavelengths, calculation.fosc, x, fwhm=30)
plt.plot(x, y)
plt.xlabel('Wavelength (nm)')
plt.ylabel('Oscillator strength')
plt.savefig('absorption_spectrum.png')
```

--------------------------------

### Parse Atomic Charges (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This code snippet demonstrates how to extract Mulliken, Löwdin, and Mayer atomic charges from an ORCA calculation output file. It uses the orca_parser library and numpy for calculations. The output includes a formatted table of charges per atom, total charges, and identifies the most positive and negative atoms based on Mulliken charges.

```python
import orca_parser
import numpy as np

calculation = orca_parser.ORCAParse("calculation.out")
calculation.parse_charges()

# Access charge arrays (numpy arrays)
mulliken = calculation.charges['Mulliken']
loewdin = calculation.charges['Loewdin']
mayer = calculation.charges['Mayer']

print("Atom  Mulliken  Löwdin  Mayer")
for i, atom in enumerate(calculation.atoms):
    print(f"{atom:4s}  {mulliken[i]:7.3f}  {loewdin[i]:7.3f}  {mayer[i]:7.3f}")

# Calculate total charge
print(f"\nTotal Mulliken charge: {np.sum(mulliken):.3f}")
print(f"Total Löwdin charge: {np.sum(loewdin):.3f}")

# Find most positive/negative atoms
most_positive = np.argmax(mulliken)
most_negative = np.argmin(mulliken)
print(f"Most positive: {calculation.atoms[most_positive]} ({mulliken[most_positive]:+.3f})")
print(f"Most negative: {calculation.atoms[most_negative]} ({mulliken[most_negative]:+.3f})")
```

--------------------------------

### Parse Amsterdam Modeling Suite (AMS) Output

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This Python snippet shows how to parse output files from the Amsterdam Modeling Suite (AMS) using the orca_parser library. It covers parsing coordinates and energies, accessing molecular data, calculating relative energies, and extracting the final structure for saving.

```python
import orca_parser
import numpy as np
from ase import Atoms

# Parse AMS output
calculation = orca_parser.ams_parse("ams_calculation.out", verbose=False)

# Check validity
print("Valid calculation:", calculation.valid)

# Parse molecular data
calculation.parse_coords()
calculation.parse_energies()

print("Atoms:", calculation.atoms)
print("Number of geometries:", len(calculation.coords))
print("Coordinates shape:", calculation.coords.shape)
print("Energies (Hartree):", calculation.energies)

# Calculate relative energies
rel_energies = (calculation.energies - calculation.energies.min()) * 627.509  # kcal/mol
print("Relative energies (kcal/mol):", rel_energies)

# Access final structure
final_coords = calculation.coords[-1]
print("Final coordinates (Å):", final_coords)

# Create ASE atoms object
molecule = calculation.asemol
molecule.write("ams_structure.xyz")

# Write trajectory for optimization
for i in range(calculation.coords.shape[0]):
    mol = Atoms(calculation.atoms, calculation.coords[i])
    mol.write("ams_trajectory.xyz", append=(i > 0))
```

--------------------------------

### Measure and Print Bond Distances (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Measures the distances of specified atom pairs (bonds) from ORCA calculation data and prints the final distance in Angstroms. It iterates through a list of bond pairs, extracts distances using the ORCA Parser, and formats the output. Requires the ORCA Parser library.

```python
bond_pairs = [(0, 1), (1, 2), (2, 3)]
for a0, a1 in bond_pairs:
    distances = calculation.scan_bond(a0, a1)
    label = f"{calculation.atoms[a0]}{a0}-{calculation.atoms[a1]}{a1}"
    print(f"{label}: {distances[-1]:.4f} Å")
```

--------------------------------

### Calculate RMSD Between Structures using orca_parser

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

This Python script demonstrates how to calculate the Root-Mean-Square Deviation (RMSD) between two molecular structures using the orca_parser library. It includes parsing coordinates from ORCA output files, calculating RMSD between final structures, and tracking RMSD along an optimization trajectory, with an option to plot the convergence.

```python
import orca_parser
import numpy as np
import matplotlib.pyplot as plt

# Parse two structures
calc1 = orca_parser.ORCAParse("structure1.out")
calc2 = orca_parser.ORCAParse("structure2.out")

calc1.parse_coords()
calc2.parse_coords()

# Calculate RMSD between final structures
coords1 = calc1.coords[-1]
coords2 = calc2.coords[-1]

rmsd = orca_parser.calc_rmsd(coords1, coords2)
print(f"RMSD: {rmsd:.4f} Å")

# Calculate RMSD along optimization trajectory
calc_opt = orca_parser.ORCAParse("optimization.out")
calc_opt.parse_coords()

reference = calc_opt.coords[-1]  # Final structure as reference
rmsd_trajectory = []

for frame in calc_opt.coords:
    rmsd = orca_parser.calc_rmsd(reference, frame)
    rmsd_trajectory.append(rmsd)

print("RMSD from final structure:")
for i, rmsd_val in enumerate(rmsd_trajectory):
    print(f"  Step {i}: {rmsd_val:.4f} Å")

# Plot convergence
plt.figure(figsize=(10, 6))
plt.plot(rmsd_trajectory, 'o-')
plt.xlabel('Optimization step')
plt.ylabel('RMSD from final structure (Å)')
plt.title('Structural Convergence')
plt.grid(True, alpha=0.3)
plt.savefig('rmsd_convergence.png')
```

--------------------------------

### Parse IR Spectrum Data with ORCAParse and Matplotlib

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Extracts infrared spectroscopy data, including frequencies and intensities, from ORCA frequency calculations. The `parse_IR()` method populates the `.IR` attribute with a pandas DataFrame. This data can be used for analysis and visualization, such as plotting the IR spectrum and identifying the strongest absorption peaks.

```python
import orca_parser
import matplotlib.pyplot as plt

calculation = orca_parser.ORCAParse("frequency_calculation.out")
calculation.parse_IR()

# Access IR spectrum as pandas DataFrame
print(calculation.IR)
# Columns: freq (cm⁻¹), eps, Int (km/mol), T**2, TX, TY, TZ

# Plot IR spectrum
plt.figure(figsize=(10, 6))
plt.stem(calculation.IR['freq'], calculation.IR['Int'], basefmt=' ')
plt.xlabel('Frequency (cm⁻¹)')
plt.ylabel('Intensity (km/mol)')
plt.title('IR Spectrum')
plt.xlim(0, 4000)
plt.savefig('ir_spectrum.png', dpi=300)

# Find strongest peaks
strongest_peaks = calculation.IR.nlargest(5, 'Int')
print("Five strongest IR peaks:")
print(strongest_peaks[['freq', 'Int']])
```

--------------------------------

### Plot Relative Energies (Python)

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Calculates and plots relative energies from ORCA calculation data. It converts energies to kcal/mol, normalizes them, and visualizes the results using Matplotlib. Requires the ORCA Parser library and Matplotlib.

```python
relative_energy = (calculation.energies - calculation.energies.min()) * 627.509
ax2.plot(relative_energy, 'o-', color='red')
ax2.set_xlabel('Optimization Step')
ax2.set_ylabel('Relative Energy (kcal/mol)')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('bond_evolution.png', dpi=300)
```

--------------------------------

### Extract HOMO-LUMO Gap and Orbital Energies with ORCAParse

Source: https://context7.com/avanteijlingen/orca_parser/llms.txt

Extracts occupied and unoccupied orbital energies, identifies the Highest Occupied Molecular Orbital (HOMO) and Lowest Unoccupied Molecular Orbital (LUMO), and calculates the energy gap. The `parse_HOMO_LUMO()` method populates attributes like `all_HOMO`, `all_LUMO`, and `HOMO_LUMO_gap`, which are particularly useful for analyzing electronic structure changes across optimization steps or different calculations.

```python
import orca_parser

calculation = orca_parser.ORCAParse("electronic_structure.out")
calculation.parse_HOMO_LUMO()

# Access orbital data for all optimization steps
print("Number of optimization steps:", len(calculation.all_HOMO))

# Final HOMO information [orbital_number, energy_Eh, energy_eV, occupancy]
homo = calculation.all_HOMO[-1]
lumo = calculation.all_LUMO[-1]

print(f"HOMO: Orbital {homo[0]}, {homo[2]:.3f} eV")
print(f"LUMO: Orbital {lumo[0]}, {lumo[2]:.3f} eV")
print(f"HOMO-LUMO gap: {calculation.HOMO_LUMO_gap:.3f} eV")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.