Procedures

Add hydrogen caps to fragment for broken bonds Caps are placed at the position of the atom outside the fragment

Add implicit solvation model to XTB calculator

Allocate array of shells in an atomic basis

Convert angular momentum character to integer

Convert angular momentum integer to character

Apply distance-based screening to filter out fragments that exceed cutoff distances Modifies polymers array in-place and updates total_fragments count

Check if two arrays are equal

Check if two atom sets are equal (assuming sorted)

Clean up allocated memory in an atomic basis

Get total number of basis functions for an atom

Allocate array of atomic basis elements in a molecular basis set

Clean up allocated memory in a molecular basis set

Compute binomial coefficient C(n,r) = n! / (r! * (n-r)!)

Build a fragment from explicit atom list (for GMBE intersection fragments)

Build a fragment on-the-fly from monomer indices with hydrogen capping for broken bonds

Build hash table for fast fragment lookups

Build molecular basis from geometry and basis file Only parses unique elements, then copies basis data to atoms

Convert calculation type string to integer constant

Convert calculation type integer constant to string

Calculate minimal atomic distance for each fragment For monomers (1-body), distance is 0.0 For n-mers (n >= 2), distance is the minimum distance between atoms in different constituent monomers

Calculate minimal atomic distance between monomers in a fragment For single monomer (size 1), returns 0.0 For multi-monomer fragments, returns minimal distance between atoms in different monomers Result is in Angstrom

Check for positive CC correlation energies (instability warning) Correlation energies should be negative; positive values indicate instability

Reset all CC components to zero

Compute total CC correlation energy

Allocate arrays for exponents and coefficients in a CGTO

Clean up allocated memory in a CGTO

Get number of basis functions in a shell (Cartesian)

Validate that fragment has no spatially overlapping atoms Checks if any two atoms are too close together (< 0.01 Bohr) This catches bugs in geometry construction or fragment building

Check if any atoms appear in multiple fragments This is O(nfrag * natoms_per_frag^2) which is acceptable for typical fragment sizes

Classify a line from a gamess formatted basis set file

Clean up CLI args

Generate all combinations of size r from array arr of size n Uses int64 for count to handle large numbers of combinations that overflow int32.

Utility for generating combinations recursively Uses int64 for count to handle large numbers of combinations that overflow int32.

Convert mass-weighted eigenvectors to Cartesian displacements.

Compute electronic entropy contribution.

Compute energy and forces for current geometry This is the main interface for optimization/dynamics codes

Compute force constants for each normal mode.

Compute generalized many-body expansion (GMBE) energy with optional gradient and/or hessian

Compute IR intensities from dipole derivatives and normal modes.

Compute many-body expansion (MBE) energy with optional gradient, hessian, and dipole

Bottom-up computation of n-body correction (non-recursive, uses pre-computed subset deltas) deltaE(i1,i2,…,in) = E(i1,i2,…,in) - sum of all subset deltaE values All subsets must have been computed already (guaranteed by processing fragments in order)

Bottom-up computation of n-body dipole correction Exactly mirrors the energy MBE logic: deltaDipole = Dipole - sum(all subset deltaDipoles) Dipoles are additive vectors in the system frame, no coordinate mapping needed

Bottom-up computation of n-body dipole derivative correction Mirrors MBE Hessian logic but for dipole derivatives Bond connectivity is accessed via sys_geom%bonds

Bottom-up computation of n-body gradient correction Exactly mirrors the energy MBE logic: deltaG = G - sum(all subset deltaGs) All gradients are in system coordinates, so subtraction is simple Bond connectivity is accessed via sys_geom%bonds

Bottom-up computation of n-body Hessian correction Mirrors MBE gradient logic but for second derivatives Bond connectivity is accessed via sys_geom%bonds

Compute the principal moments of inertia and detect linear molecules.

Compute partition functions for translation, rotation, and vibration.

Compute the atom list for a polymer (union of atoms from base fragments) polymer(:) contains base fragment indices (1-based)

Compute reduced masses for each normal mode.

Convert moments of inertia to rotational constants in GHz.

Compute rotational contributions to thermodynamic properties.

Main driver for thermochemistry calculations.

Compute translational contributions to thermodynamic properties.

Perform complete vibrational analysis from Hessian matrix.

Compute vibrational frequencies from the Hessian matrix.

Compute vibrational contributions to thermodynamic properties.

Compute zero-point vibrational energy from frequencies.

Clean up allocated memory in mqc_config_t

Log method-specific settings based on method type

Reset all configuration values to defaults

Convert mqc_config_t to minimal driver_config_t Extracts only the fields needed by the driver If molecule_index is provided, uses that molecule’s fragment count

Convert mqc_config_t geometry to system_geometry_t For unfragmented calculations (nfrag=0), treats entire system as single unit For fragmented calculations, currently assumes monomer-based fragmentation If molecule_index is provided, uses that specific molecule from multi-molecule mode

Configure a DFT method instance from config%scf (shared) and config%dft (DFT-specific)

Configure a Hartree-Fock method instance from config%scf (shared SCF settings)

Configure a MCSCF method instance from config%mcscf

Configure an XTB method instance from config%xtb

Create a copy of reference geometry with one coordinate displaced

Deep copy of atomic basis data from source to dest

Count how many hydrogen caps are needed for a fragment A cap is needed when exactly one atom of a broken bond is in the fragment

Count the number of shells for a specific element in a GAMESS formatted basis string,

Convenience function to create a method without instantiating factory

Generate a list of monomer indices from 1 to N

DFS helper: accumulate PIE coefficients for intersections

Calculate electronic energy using Kohn-Sham DFT

Calculate energy gradient using Kohn-Sham DFT

Calculate energy Hessian using Kohn-Sham DFT

Clean up memory for displaced geometry

Return atomic mass in atomic mass units (amu) for a given atomic number Uses standard atomic weights from IUPAC

Convert atomic number to element symbol Covers the complete periodic table (elements 1-118)

Convert element symbol to atomic number Covers the complete periodic table (elements 1-118)

Check if string ends with suffix

Reset all energy components to zero

Compute total energy from all components

Add a call location to the stack trace Typically called when propagating errors upward

Clear the error state and stack trace

Get the error code

Get complete error message with stack trace Returns a multi-line string with error and call stack

Get the error message (without stack trace)

Check if an error is set

Print error with stack trace to specified unit If unit not specified, prints to stdout (unit 6)

Set an error with code and message Resets the stack trace

Extract the basis set data for a specific element from the basis file

Create a quantum chemistry method instance from configuration

Fill in the shell data for a specific element from a GAMESS formatted basis string

Find basis set file using normalized name

Find shared atoms between two fragments (for GMBE with overlapping fragments)

Find unique strings in an array Returns array of unique strings and count

Compute dipole moment derivatives via central finite differences

Compute Hessian matrix from finite differences of gradients

Compute number of electrons from atomic numbers and charge

Clean up allocated memory in physical_fragment_t

Clean up hash table and all chains

Find fragment index for given monomer combination

Initialize hash table with estimated size

Insert a monomer combination -> fragment index mapping

Set the basis set for this fragment

Check if a fragment should be screened out based on distance cutoffs. Returns true if the fragment itself OR any of its k-subsets (k >= 2) exceeds the corresponding k-mer cutoff. This ensures MBE subset consistency.

Generate all possible fragments (combinations of monomers) up to max_level Uses int64 for count to handle large numbers of fragments that overflow int32.

Generate all k-way intersections for k=2 to min(max_intersection_level, n_monomers)

Generate k-way intersections from arbitrary atom lists (not tied to sys_geom) max_k_level limits the maximum intersection order to prevent combinatorial explosion

Helper to generate all k-way intersections at a specific level k

Generate all k-way intersections from atom lists

Generate all forward and backward displaced geometries for finite difference calculations

Generate all k-way intersections for polymers at any level (GMBE-N) This works with dynamically generated polymers, not just base fragments

Clean up allocated memory in geometry_type

Convert geometry to system_geometry_t for fragmented calculation Supports both identical and variable-sized fragments

Convert geometry to system_geometry_t for unfragmented calculation Treats entire system as a single monomer

Get the base name without “output_” prefix and “.json” suffix Example: “output_w1.json” -> “w1”

Map body level (n-mer) to descriptive name Supports up to decamers (10-mers), then falls back to “N-mers” format

Convert string log level to integer value This function uses the pic_logger constants

Extract molecule name from filename Example: “output_multi_structure_molecule_1.json” -> “molecule_1”

Build 0-indexed atom list for a monomer, handling fixed or variable-sized fragments.

Generate next combination (updates indices in place) has_next = .true. if there’s a next combination

Extract the next line from a string starting at line_start

Calculate total number of fragments for given system size and max level

Get the current JSON output filename

Get dielectric constant for a named solvent

Clean up GMBE context

Enumerate all unique intersections via DFS and accumulate PIE coefficients This implements the GMBE(N) algorithm with inclusion-exclusion principle

Initialize GMBE context with required configuration

MPI coordinator for PIE-based GMBE calculations Distributes PIE terms across MPI ranks and accumulates results If json_data is present, populates it for centralized JSON output Bond connectivity is accessed via sys_geom%bonds

Run distributed GMBE calculation

Run serial GMBE calculation

Grow PIE term storage arrays when capacity is exceeded.

Calculate electronic energy using Hartree-Fock method

Calculate energy gradient using Hartree-Fock method

Shared helper to initialize system_geometry_t for fragmented calculations Handles fragment allocation, size checking, and overlap validation

Read full geometry and monomer template, initialize system_geometry_t

Clean up allocated memory in input_fragment_t

Convert integer to string

Compute intersection of two atom lists

Check if a line is blank or a control line (starts with ‘$’)

Check if a line is a function coefficient line (starts with a number)

Check if character is a letter (A-Z or a-z)

Check if a line is a shell header line (starts with S, P, D, F, G, H, I, or L)

Check if character is an uppercase letter (A-Z)

Clean up all allocated memory

Reset all flags and scalar values to defaults

Map fragment dipole derivatives to system coordinates with hydrogen cap redistribution

Map fragment gradient to system gradient coordinates with hydrogen cap redistribution

Map fragment Hessian to system Hessian coordinates with hydrogen cap redistribution Bond connectivity is accessed via sys_geom%bonds

Apply mass weighting to Hessian matrix.

Clean up base class resources

Check if system geometry is available

Check if MPI resources are available

Clean up MBE context

Initialize MBE context with required configuration

Allocate dipole array (always 3 components)

Allocate gradient array for total_atoms

Allocate hessian array for total_atoms

Clean up allocated memory in mbe_result_t

Reset all values and flags in mbe_result_t

Run distributed MBE calculation

Run serial MBE calculation

Calculate electronic energy using CASSCF

Calculate energy gradient using CASSCF

Calculate energy Hessian using CASSCF

Merge individual molecule JSON files into a single combined file

Convert method type string to integer constant

Convert method type integer constant to string

Get total number of basis functions for the molecule

Clean up allocated memory in molecule_t

Convert a molecule_t to system_geometry_t Handles both unfragmented (nfrag=0) and fragmented molecules

Check for positive MP2 correlation energies (instability warning) Correlation energies should be negative; positive values indicate instability

Reset both MP2 components to zero

Compute SCS-MP2 (Spin-Component Scaled MP2) correlation energy SCS-MP2 uses: E_SCS = (1/3)E_SS + 1.2E_OS

Compute total MP2 correlation energy

Generate next combination in lexicographic order Returns .true. if there’s a next combination, .false. if we’ve exhausted all

Initialize combination to [1, 2, …, k]

Find next prime number >= n (simple implementation)

Normalize basis set name to filename-safe format

Placeholder for Hessian calculation

Open and read a GAMESS formatted basis set file

Parse command line arguments for geometry file and basis set

Parse basis set for a specific element from a GAMESS formatted basis string

Parse function line (e.g., “1 1.0 2.0” or “1 1.0 2.0 3.0” for L shells)

Parse method string from input file (e.g., “XTB-GFN1” -> gfn1)

Parse %connectivity section for a molecule

Parse %fragments section for a molecule

Parse %geometry section for a molecule

Parse %structure section for a molecule

Parse shell header line (e.g., “S 2” or “L 3”)

Parse a single %molecule block with its sections

Populate json_data with basic unfragmented calculation results

Populate json_data with vibrational analysis results

Print combinations stored in out_array Uses int64 for count to handle large numbers of combinations that overflow int32.

Print detailed energy breakdown for each fragment Shows full energy and deltaE correction for all monomers, dimers, trimers, etc. Uses int64 for fragment_count to handle large fragment counts that overflow int32.

Print fragment geometry in XYZ format

Print GMBE energy breakdown using inclusion-exclusion principle

Print GMBE gradient information

Print debug information about GMBE intersections

Print the PIC Chemistry ASCII sunflower logo

Print MBE energy breakdown to logger

Print MBE gradient information

Print thermochemistry results.

Print usage information

Print vibrational analysis results in a formatted table.

Process derivatives for a single intersection fragment

Project out translation and rotation modes from mass-weighted Hessian.

Read and write JSON content from an individual molecule file Properly handles nested structures from fragmented calculations

Read and parse a .mqc format input file

Read molecular geometry from XYZ format file

Parse molecular geometry from XYZ format string

Redistribute hydrogen cap dipole derivatives to original atoms

Redistribute hydrogen cap gradients to original atoms

Redistribute hydrogen cap Hessian to original atoms

Clean up resources

Initialize resources with default values

Clean up allocated memory in calculation_result_t

Receive calculation result over MPI (non-blocking) Receives SCF energy (non-blocking) and other components (blocking)

Send calculation result over MPI (non-blocking) Sends SCF energy (non-blocking) and other components (blocking)

Receive calculation result over MPI (blocking) Receives energy components and conditionally receives gradient based on flag

Reset all values and flags in calculation_result_t

Send calculation result over MPI (blocking) Sends energy components and conditionally sends gradient based on has_gradient flag

Main calculation dispatcher - routes to fragmented or unfragmented calculation

Handle fragmented calculation (nlevel > 0)

Run calculations for multiple molecules with MPI parallelization Each molecule is independent, so assign one molecule per rank

Handle unfragmented calculation (nlevel=0)

Send fragment data to remote node coordinator Uses int64 for fragment_idx to handle large fragment indices that overflow int32.

Send fragment data to local worker Uses int64 for fragment_idx to handle large fragment indices that overflow int32.

Send PIE term (atom list) to remote node coordinator

Send PIE term (atom list) to local worker

Serial GMBE processor using PIE coefficients Evaluates each unique atom set once and sums with PIE coefficients Supports energy-only, energy+gradient, and energy+gradient+Hessian calculations If json_data is present, populates it for centralized JSON output Bond connectivity is accessed via sys_geom%bonds

Append a suffix to the output filename (e.g., for multi-molecule mode) Example: suffix=”_mol1” -> “output_multi_structure_mol1.json”

Set the JSON output filename based on input filename Example: “water.mqc” -> “output_water.json”

Skip lines until ‘end’ marker is found

Sort fragments by size (largest first) for better load balancing Uses in-place sorting to reorder the polymers array Larger fragments (e.g., tetramers) are computed before smaller ones (e.g., dimers)

Split input text into lines based on CR, LF, or CRLF line endings Trailing newlines do not create empty lines

Compare two strings after trimming and adjusting (removing leading/trailing whitespace) Compare two strings for equality after trimming and adjusting (removing leading/trailing whitespace)

Remove comments (! or #) from a line and trim result

Synchronize geometry coordinates from master rank to all worker ranks This is needed when master rank updates coordinates for optimization/dynamics

Clean up allocated memory in system_geometry_t

Convert coordinate from Bohr to Angstrom

Convert coordinate from Angstrom to Bohr

Convert a string to uppercase, should use pic_ascii!

Validate that fragment cutoffs are monotonically decreasing For n-mer level N, cutoff(N) must be <= cutoff(N-1)

Write GMBE PIE calculation results to output JSON file

THE single entry point for all JSON output

Write detailed MBE energy breakdown to JSON file

Write unfragmented calculation results to output JSON file

Write vibrational analysis and thermochemistry results to JSON file

Calculate electronic energy using Extended Tight-Binding (xTB) method

Calculate energy gradient using Extended Tight-Binding (xTB) method

Calculate Hessian using finite differences of gradients

Configure XTB solvation settings from driver configuration

Get solvation configuration info for logging

Check if solvation is configured for XTB