Search the Site Index:





GauOpen: Interfacing to Gaussian 26 (v3)

Updated on 15 Oct 2026

Interfacing Quantum Chemistry Programs

There are a variety of circumstances where it is useful to run one or more calculations in a program as part of a larger simulation task, or to do parts of a calculation in one program and other parts in another. This document presents our general approach to this problem. The examples refer to Gaussian but the approach and libraries supplied here can be useful with any atomistic simulation software. Details about the structure of the files and the associated interfacing library are presented in separate documents.

The many reasons for interfacing programs to other programs and environments fall into five general categories: Automation, Post-Processing, Integration, Experimentation, and Teaching. In order to make this discussion more concrete, we start with some specific examples.

Example uses for a standardized interface

  • Automation
  • Post-Processing
  • Integration
  • Experimentation
  • Teaching

Among the many reasons for running Gaussian within scripts as part of larger procedures or in conjunction with other programs are:

  • Scripting to automate running multiple related Gaussian jobs. This usually involves providing initial structures to Gaussian and retrieving final computed quantities such as energies or force constants. It is typically done with the usual sort of shell scripts or programs in scripting languages such as Python and Perl.
  • Post-processing of the detailed results of calculations done by Gaussian, such as visualization or analysis of wavefunctions or densities.
  • Computations in other programs which can use intermediate data generated by Gaussian, avoiding the need to code functionality in the other program which duplicates functionality already in Gaussian. These fall into three categories:
    a. Production calculations, which would typically be implemented in a compiled language such as Fortran or C. For example, SCF methods which such as Valence Bond methods or unusual MCSCF methods can use one and two electron integrals computed by Gaussian, and similarly post-SCF methods can use the required integrals over molecular orbitals produced by Gaussian.
    b. Prototyping new models or methods. This might be done in either a compiled language or an interpreted one such as Python. It is convenient to have all the quantities which Gaussian can compute be available so that only the unique aspects of the new model need to be implemented and debugged.
    c. Classroom exercises, which are usually done using interpreted languages such as Python, Jupyter notebooks or MatLab, where the excercise can focus on a specific aspect of theory without having to provide code for unrelated parts. For example, an exercise in which students code a simple SCF algorithm with having to evaluate integrals, or work with harmonic vibrational analysis using structues and Hessians computed using Gaussian.
  • Models which integrate capabilities in Gaussian and those in another program within a single overall computation. The overall calculation might be controlled by either program.
    a. Tasks where Gaussian might control would include using Gaussian’s algorithms for geometry optimization, reaction path following, or dynamics with models for the energy and derivatives provided by another program. These could also be performed using the ONIOM multiscale model with another program providing the model at one level of theory in the ONIOM.
    b. Tasks where Gaussian might be controlled by another program would include models in which Gaussian was used to provide energies, Fock matrices, and the like given densities provided by the controlling program. Natural Bond Order analysis of energy contributions by deleting particular terms in the density matrix is a typical example. Similarly, Gaussian-Tinker interface in which Tinker controls QM/polarizable MM dynamics involves the exchange of density matrices and not just geometric information
  • Pedagogical use, such as incorporating calculations within Jupyter notebooks and other interactive presentations of quantum chemistry methods and models.

Issues with existing solutions

In the past, some people have used functionality from Gaussian by linking the executables for their programs with Gaussian’s libraries, or by having their code called within a Gaussian link. However, this is problematic in many ways. It requires Gaussian source code, that the user compile their own code with the same compiler and options as Gaussian, and that the user understand the internal data structures and calling conventions within Gaussian. It made the resulting code fragile in that internal changes in future versions of Gaussian, transparent to ordinary users, could break the user’s code. In addition, it creates unnecessary compilications with respect to code ownership and intellectual property.

We have provided the formatted checkpoint file as an interface mechanism, particularly for post-processing of results from Gaussian. It is self-defining and extensible as a text file it provides a relatively simple format to read. It is also easy to move between machines running different operating systems or having different forms for binary data. While it is suitable for post-processing results from Gaussian, especially for visualization, it is not adequate as a general interface because the limited precision with which values are stored is not sufficient for intermediate data such as integrals, and because reading and writing the file is expensive when large amounts of data are involved because of the conversion to and from text form. Also, since the file was intended for post-processing and for moving data between Gaussian running on different types of hardware, its contents mirror many of the internal Gaussian data structures.

Gaussian also provides .wfn and .wfnx files, which are used by several programs that post-process wavefunctions or densities. These are also text files and have similar limitations to the formatted checkpoint file. They are not Gaussian-centric but have specific data structures which arise from their original purposes. For example, the basis set and molecular orbitals are expressed directly in terms of the primitive Gaussian basis, omitting all contraction information.

In the past, some people have used functionality from Gaussian by linking the executables for their programs with Gaussian’s libraries, or by having their code called within a Gaussian link. However, this is problematic in many ways. It requires having Gaussian source code, that the user compile their own code with the same compiler and options as Gaussian, and that the user understand the internal data structures and calling conventions within Gaussian. It made the resulting code fragile in that internal changes in future versions of Gaussian, transparent to ordinary users, could break the user’s code. In addition, it created unnecessary complications with respect to code ownership and intellectual property.

Goals for a General Interface

Our goals for a general interface are to facilitate all of the above uses in clean and maintainable ways. It should:

  • Allow communication between other programs or scripts and standard Gaussian binaries without requiring recompilation, modification of Gaussian, or access to Gaussian source code.
  • Be as simple for the user as possible, in particular by providing an interface which does not require knowledge of Gaussian’s internal data structures or algorithms, and requiring as little knowledge of the internal structure of interface files as possible.
  • Be self-defining and upward compatible, so that new types of data and new functionality can be added without breaking user code which works with a previous version of the interface. This also facilitates storage of data unrelated to Gaussian by other programs.
  • Retain the full precision of the computed quantities.
  • Be reasonably efficient when large amounts of data (gigabytes rather than megabytes) are transferred.
  • Facilitate use of Gaussian as either the controlling or the subordinate program.
  • Be a non-Gaussian-centric as possible, both for ease of use and to facilitate code use of the interface for communications with other quantum chemistry codes which provide the same interface.
  • Function transparently on all major operating systrems, in particular supporting Windows as well as Unix.
  • Support communication with other program systems in a wide range of languages, including interpreted languages such as Python and Perl and compiled languages such as Fortran and C/C++

Our new interface meets this goals.

Structure of the General Interface

There are three basic components of the GauOpen interface:

  • A binary data file which is self-defining but reasonably compact, and which attempts to store standard data in simple forms rather than using Gaussian’s internal data structures. These forms are supported in either Fortran unformatted form, which is useful for interfacing to programs in Fortran or Python, and as raw binary data, which is suitable for use in C, C++, and Perl programs. Data is organized in the same way in either type of file. Details of the file structure can be found in the BAF & FAF tab. The formchk and unfchk utilities can convert between Gaussian checkpoint files and either type of binary interface file.
  • Libraries and scripts which provide easy-to-use interfaces for reading and writing these file. They are open source and hence can be easily incorporated in user programs.
  • Functionality within Gaussian to use such binary data files as input or output for complete Gaussian jobs and as input/output between Gaussian and external programs being run from within Gaussian. A subordinate program is connected to Gaussian via the External interface. Such a program can be used:
    In lieu of a Gaussian SCF link.
    As a post-SCF step using orbitals generated within Gaussian.
    To compute derivatives for use in optimizations and frequency calculations controlled by Gaussian.
    To perform one or more of the sub-calculations within an ONIOM model.

Gaussian can also be run as a subordinate program, taking most or all of its input from a data file provided by the controlling program, and producing a new data file containing the results from Gaussian.

About the Interface Libraries and Scripts

Open-source interface routines

These are libraries and scripts which provide easy to use interfaces for reading and writing these files, which are provided separately from Gaussian, are open-source and hence can be incorporated in user programs. They are described in library.txt, with further details in the individual source routines.

Open-Source Interface for Binary Array Files

These are libraries and scripts which provide easy to use interfaces for reading and writing these files, which are provided separately from Gaussian, are open-source and hence can be incorporated in user programs. They are described in library.txt, with further details in the individual source routines.

Fortran interface

The low-level Fortran routines are in qcmatrixio.F and qcmatrixiou.F, and the higher-level routines are in qcmatrix.F. The data is stored in a Fortran unformatted file, with records limited to 32K bytes each. This limitation ensures tha file can be read or written by code build using most common compilers (nvidia, gfortran, and ifort at least). The same source code is used to build two libraries, one using 32-bit integers and the other 64-bit.

C/C++ interface

The C/C++ interface library which provides two levels of interface:

  • A low-level interface (qcmatrixio.c) with the same functionality as the Fortran interface, intended for production use on large data sets.
  • A higher-level interface in an object-oriented style (qcopmatc.c and qcbinarc.c), which facilitates access to all the data at once. This is c rather than C++ code but works with objects and methods and can easily be incorporated with a program’s C++ object structure. The methods and objects provided are similar in structure to those described below in the Python interface.

These work with binary array files stored as raw binary files. the same source is compiled into two libraries, one for files using 32-bit integers and one for 64-bit integers.

Python interface

  • Python modules which provide a full object oriented interface. This provides easy access to the data as numpy arrays, works in Jupyter notebooks, and provides methods which allow transparent access to Gaussian to add or process data in the objects. Reading and writing binary array files is done by wrapping the Fortran and c libraries with f2py and cffi, respetively, so the Python modules can handle files stored as either Fortran unformatted or raw binary files and with either size of integer.

to programs in Fortran, and as raw binary data, which is more suitable for use in C, C++, and perl programs. Our Python interface and Gaussian itself support both types of file. Data is organized in the same way in either type of file. Details of the file structure are given in appendix I, and the code is available from the Gaussian website at http://gaussian.com/interfacing.

Perl interface.

Perl modules (BinAr.c and OpMat.c) provide a basic but object-oriented interface. These work with binary array files stored as raw binary files.

examples?

The open-source interface libraries and scripts have reached varying degrees of maturity depending on the extent of use so far. The Fortran interface routines (in qcmatrix.F, qcmatrixio.F, and qcmatrixiou.F) provide for convenient reading and writing data from the files with minimal knowledge of their structure. The Python modules import the Fortran interface via f2py but add higher-level functionality, including object interfaces for both the individual items in the file (atomic coordinates, operator matrices, etc. in OpMat.py) and for the entire file as an object (in QCMatEl.py). In addition to reading and writing the file, the file object also provides methods to transparently run Gaussian to generate additional data, so a Python user can request and consume results from Gaussian without any knowledge of Gaussian’s input or any knowledge of the structure of the interface file on disk. The actual data from the file are stored as NumPy arrays and hence are useful directly in NumPy and SciPy routines. The Perl modules (OpMat.pm and MatEl.pm) provide transparent object interfaces to the data items and entire file in the same style as the Python modules, but do not include all of the higher level functionality. Details of all the interfaces are in the comments in the source files. The Fortran interfaces have been tested with the PGI, Gnu, and Intel fortran compilers. The Python interface uses many features of Python3 and is not supported with Python2.

Along with the interface routines are example programs which demonstrate the interfaces. These include routines to read and print a data file and to write a file from internally stored data, using either the Fortran or Python interfaces. There is also a module which replaces the one and two-electron integral module in the PyQuante2 program with code that generates the Gaussian data file from the PyQuante2 data structures, runs Gaussian, and returns the integrals in the form expected by PyQuante2. There are also Gaussian input files which generate data files including MO two-electron integrals and example programs in Fortran, Python, and Perl (domp2.F, domp2.py, and domp2.pl) which read these data files and compute the MP2 energy.

The interface routines assume 4 byte integers in the data file. For the raw form of the file, a fixed integer size must be assumed because there is no reliable way to determine this when the file is read. Since both perl and python currently use 32-bit addressing and cannot handle arrays larger than 2GB, this is not a limitation for these languages. The Fortran interface routines can be made to read and write with 8 byte integers by adding a preprocessor directive, and the makefile builds both 4-byte versions of the read and write examples (readmat and writemat) and 8-byte versions (readmat8 and writemat8).

Interface files in the GauOpen directory

The Fortran interface files are in qcmatrixio.F and qcmatrixiou.F, which contains low-level I/O routines which are used by both the Fortran and Python interfaces, and qcmatrix.F, which contains routines which write elements of the file and which have a cleaner interface for Fortran callers. The individual routines are documented in the files.

The Python interface uses the fortran interface wrapped by f2py to read and write data files. The wrapped routines can be called directly in Python, but a much more flexible and object-oriented interface is provided by the higher level interface in OpMat.py, which provides an operator matrix object class for individual operator objects in the file, and QMatEl.py, which provides a class for the complete data file. All integer and floating point arrays are stored within an operator matrix as numpy arrays and can be used directly with the standard numpy and scipy routines for vector and matrix operations. The matrix element file class provides methods for reading and writing entire files and also for running a Gausian job to populate a matrix element object with additional data.

Example programs and scripts in the GauOpen directory

The example programs readmat.F and writemat.F provide simple examples of reading and writing matrix element files in Fortran. readmat.py and writemat.py provide the same examples in Python, and readmat.pl and writemat.pl in Perl. The makefile qc.make builds the Fortran routines and programs as well as the python interface. The .gjf files are Gaussian input files for jobs which generate sample matrix element files read by the other examples. domp2.F reads one of these files and computes the MP2 energy for the molecule, domp2 illustrates the same task in Python, and domp2.pl does the same in Perl. pyquante2-interface.py provides a replacement for the one and two electron integral generator classes in the PyQuante2 program which takes the internal PyQuante2 data, generates a matrix element object containing the minimal information (coordintes, atomic numbers, etc.), runs Gaussian to populate the object with the required integrals and returns them in the form expected by PyQuante2.

Binary Array File (BAF)

This is a binary file which has a few fixed records at the beginning which include the information most common to computational chemistry calculations, followed by self-defining records containing additional data. The header information, which includes information such as number of atoms, coordinates, and other details of the calculation, can all be dummied if this information is not needed. The main contents of the file consist of a short record with a fixed structure labelling a data object followed by the contents of that object, repeated as needed. The fixed structure record gives the data type and dimensions for the object and the length of the records containing the object’s data. The additional data can be character, integer, real or complex floating point values. It can reflect any organization, although the fixed records are oriented towards multidimensional array objects.

Details of the file format are in binarfile.txt.

Capabilities in Gaussian to generate and use BAFs are documented in gaussian.txt.

BAF Functionality with Gaussian 16

Gaussian can interact with binary array files in a variety of ways. Files can provide most or all of the input for a calculation in Gaussian, they can be generated with intermediate or final results from a calculation, and they can be used for communication of data to and from other programs run from within Gaussian using its external interface/keyword.

The formchk and unfchk utility programs can convert between BAFs and Gaussian’s internal data files (chk, rwf, and fchk files).

Output Route keyword.

The Output route keyword requests that a BAF or FAF be written at the end of the Gaussian job step. The name of the file is read from the Gaussian input file. The options which control the data to be included in the file can also be used to control the contents of a file which is named using a switch on the Gaussian command-line. The options for the Output keyword include:

  • RawMatrixElement — requests that a BAF be written
  • MatrixElement — requests that a FAF be written
  • I4Labels, I8Labels — specifies the length of integers used in the file. The default is 4 byte integers for a BAF and the integer size used in the Gaussian version for a FAF.

Other keywords control which items are included in the file. Refer to the Gaussian documentation for details.

Command-line and link0 input options for reading and writing bafs.

Utilities

  • Formchk
  • unfchk

External program interface

Data stored by Gaussian in BAFs

Functionality within Gaussian

  • full or partial input to G, just route on command line. facilitates generating G jobs in scripts or running from other programs.
  • output a end of job, job-step, or at intermediate points to monitor calculation or post-process.
  • external interface.

for input, output, at intermediate points during calculations, in/out to files, route on command line, external interface, utillities.

The quantities stored in the file by Gaussian are straightforward arrays extracted from Gaussian’s internal data structures. The specific data objects currently understood by Gaussian are in Appendix 2, but this list is expected to grow over time.

Functionality within Gaussian to use these data files as input or output for complete Gaussian jobs and as input or output between Gaussian and external programs being run from within Gaussian. In addition, the formchk and unfchk utiltiies can convert between Gaussian internal binary files and either type of interface file.

The interface will continue to evolve as additional capabilities are required. The quantities which are currently available in the data file include the most common quantities used in SCF and post-SCF calculations, such as the location and identities of atoms, basis set, one and two eletron integrals over atomic orbitals, molecular orbital coefficients, and two electron integrals over molecular orbitals.

The functionality in Gaussian allows use of a subordinate program via the External interface either in lieu of a Gaussian SCF link or as a post-SCF step using orbitals generated within Gaussian, can recover derivatives for use in optimizations and frequency calculations controlled by Gaussian, and a subordinate program can be used as one or more of the sub-calculations within an ONIOM model. Gaussian can be run as a subordinate program taking most or all of its input from a data file provided by the controlling program, and producing a new data file containing the results from Gaussian.

Generating interface data files in Gaussian

A formatted checkpoint file can be produced in three ways:

  • By using the formchk utility to convert the binary checkpoint file left after a Gaussian job.
  • Generated when an external script or program is to be run as part of the calculation in Gaussian.
  • By using the -fchk=… switch on the g16 command line, which causes a formatted checkpoint file to be written or rewritten at each “interesting” point of a job step (new geometry during an optimization, end of the job step, etc.).

The binary array file can also produced in three ways;

  • By using the formchk utility to convert the binary checkpoint file left after a Gaussian job.
  • Generated when an external script or program is to be run as part of the calculation in Gaussian.
  • Using the Output=BAF or Output=FAF route commands to cause a file to be generated at the end of the current Gaussian job step.

Using data files as input to Gaussian.

A binary array file can be used as input to Gaussian by converting to a binary checkpoint file using the unfchk utility and then using the %chk or %oldchk link-0 command to provide the file to the Gaussian job step. In addition, a matrix element file can be specified as input using the %oldmatrixelement or %oldrawmatrixelement link-0 commands. These take the data from the matrix element file and move it to the checkpoint file for the current job step, where it can be used to provide the geometry, initial wavefunction, etc.

External Keyword in Gaussian

Gaussian has the capability to run an external script or program as part of a calculation, and either a formatted checkpoint file or a matrix element file can be used to provide input and/or output from the external program. Refer to g16/doc/extern.txt for details.

Running Gaussian from within other programs.

There are at least two ways this can be done. The other program can generate an Gaussian input file, which in turn can request input from a data file and which generates a data file containing results, and then run Gaussian in a subprocess using the unix system command, fork/exec, or equivalent functionality. Alternatively, the Python interface (QCMatEl.py) provides a matrix element class which includes methods which automatically run Gaussian and update a matrix element object with additonal data. This can be used directly by a program in Python, or a program in another language can create a subprocess running a simple python script which in turn runs Gaussian.

This is a simple self-defining binary file designed to import and export data. The structure is designed to facilitate communication of array data. The fixed header records at the beginning of the file hold information related to calculations on molecules, but these are dummied by default so it is trivial to use the files for any sort of real, integer, or character array data.

The file can be in either a raw binary file no record structure explicitly on the file (BAF) or a Fortran Array file (FAF), which has record length information at the beginning and end of each record provided by the Fortran run-time. The Fortran version facilitates reading and writing the files in Fortran programs, while the raw binary format is simpler for C/C++ and Perl. Since most current Fortran compilers, including Intel, PGI/NVidia, and gfortran, use the same format for unformatted files having records of length 65535 bytes or less, large objects are split up into records shorter than this. Consequently, a program compiled with any of these compilers or Python code using the interface compiled with any compiler can exchange data with other programs even if those were built with a different compiler. The file also contains enough information so that a program reading the raw binary form can determine the length for each I/O request from data read previously. Separate interface libraries are compiled for 32 and 64 bit integers. The Python interface imports both of the Fortran interface via f2py and both of the c interfaces via CFFI and can read and write any of the four file structures.

The file has 11 or more fixed-content records at the beginning, followed by zero or more arrays, each of which has a label record which describes the array, followed by records containing the array in chunks given by the buffer size given in the array’s label record. Most of the data in these records is specific to calculations on a molecular system, but if a file is to be used to transfer some arrays without any need for specification of a molecule, thesw records can be dummied with NAtoms=1 NBasis=1 and zero for the other dimensions and the contents of the one-element arrays. A BinArFile object is created with these records dummied, while the QCBinAr initializer can populate these records by reading a file.

The fixed content records:

Record Format and Description
1 Character*64 LabFil, Integer IVers, Integer NLab, Character*64 GVers
A label for the file type, version number for the file format, number on general data records which follow and preceed the matrix elements, and the version of Gaussian which wrote the file.
2 Character*64 Title, Integer NAtoms, NBasis, NBsUse, ICharg, Multip, NE, Len12L, Len4L, IOpCl, ICGU
The first 64 characters of the title section from the run which created the file and the number of atoms and basis functions. NBsUse is the number of linearly independent basis functions. ICharg is the molecular charge, Multip the spin multiplicity (1=singlet, etc.) and NE the number of electrons. Len12L is the number of bytes used for the integer labels for sparse 1d and 2d matrices and Len4L is the number of bytes used for sparse 4d matrices (2e integrals). IOpCl is the closed/open-shell flag if the file is written after an initial guess or SCF has been done; otherwise it is -1, meaning unspecified.
The current interfaces always make Len12L=Len4L= 4 or 8.
ICGU encodes whether the calculation is complex and/or GHF in a simpler way than IOpCl — it is KLM, where
K=1/2 for spin-aligned vs GHF
L=1/2 for real vs complex
M=1/2 for RHF/GHF vs UHF (1 vs 2 spin blocks)
If IOpCl=-1, it is generated from ICGU. If ICGU=0, it is generated from IOpCl. If both are present, they are checked for consistency.
If K=2 (GHF), then NBasis is the number of spatial AO basis functions but operator matrices are over the spinorbital basis and hence have dimension K*NBasis.
3 Integer IAn(NAtoms)
Atomic numbers, padded to an even number of integers if using I*4.
4 Integer IAtTyp(NAtoms)
Atom type information. The main aspect of interest to other programs is that negative values indicate inactive atoms during an ONIOM model system calculation. By default, the file is written with inactive atoms omitted from all arrays and NAtoms set to the number of active atoms, but all atoms can optionally be included. Padded to an even number of integers if using I*4.
5 Real*8 AtmChg(NAtoms)
Nuclear charges, may be different from atomic numbers if ECPs were used.
6 Real*8 C(3,NAtoms)
Cartesian nuclear coordinates in Bohr.
7 Integer IBfAtm(NBasis), IBfTyp(NBasis)
IBfAtm is the map from basis functions to atoms.
IBfTyp is a type flag for each basis function. Each is of the form LLLMMM, where LLL is the angular momentum and MMM is the component number. Negative values are for pure functions and positive for Cartesian. So cartesian D’s are numbered 2001 through 2006 and pure D’s are -2001 through -2005.
8 Real*8 AtmWgt(NAtoms)
Atomic weights.
9 NFC, NFV, ITran, IDum
Window information for MO 2e integrals. The MOs include NFC frozen core orbitals and NFV frozen virtuals, so MO 2e integrals will be over NBsUse–NFC–NFV orbitals. ITran=0 if no MO integrals were stored, ITran=4 if only MOs involving at least one occupied orbital were stored, or ITran=5 if a full transformation was done.
10 to NLab will contain other scalar data about the calculation. Currently NLab is 7, 9, or 11. Programs should skip records up to to NLab to ensure that they ignore data which is added here later.
If NLab>9 then record 10 should be NLab-10 integers giving the number of 32-bit words in each of the remaining initial sections, so that these can be skipped when the file is stored without record marks/lengths.
11 is 16 additional integers. Currently only first 10 are used:
NShellAO — Number of contracted shells of AO basis functions, needed if shell data is provided.
NPrimAO — Number of primitive AO shells.
NShellDB — Number of contracted shells of density fitting functions, needed if fitting shell data is provided.
NPrimDB — Number of primitive density fitting shells.
NBTot — Total Number of bonds in connectivity data, if any.
NNDeriv — Number of numerical derivatives/perturbations done.
NND12 — Flag for type of numerical derivatives: 1/2 for first or first+diagonal second and +/- for Cartesian or normal mode.
NFreqPt — Number of frequencies in frequency-dependent perturbations, if any.
NShNEO — Number of contracted NEO shells, if any.
NPrNEO — Number of primitive NEO shells, if any.

Data Arrays

The arrays, if any, consist of:

Character*64 Label, Integer NI, NR, NTot, NPerRec, N1, N2, N3, N4, N5, IAType

The initial record has a label for the data, followed by the number of integers and number of reals for each element, the total number of elements and number of elements per record. NI can be zero for dense matrices (stored with zeros included). NR is negative to flag complex rather than real data. This is followed by (NTot+NPerRec-1)/NPerRec records each of the form:

if NI>0 NR>0 the array is real stored in sparse form with indices for the non-zero elements:

Integer ID(NI,NPerRec), Real*8 DX(NR,NPerRec)

if NI>0 NR<0 the array is complex stored in sparse form with indices for the non-zero elements:

Integer ID(NI,NPerRec), Complex*16 DX(-NR,NPerRec)

or if NI=0 and NR=1 the array is real with full (uncompressed) storage:

Real*8 DX(NPerRec)

or if NI=0 and NR=-1 the array is complex with full (uncompressed) storage:

Complex*16 DX(NPerRec)

or if NI=1 and NR=0 the array is integers:

Integer ID(NPerRec)

Here LenBuf is the size of the buffer (or each buffer if NI and NR are both non-xero), so NPerRec=LenBuf/Max(NI,Abs(NR)). A typical value for LenBuf is 4000, which ensures that each record in a Fortran unformatted file is less than 65535 bytes.

N1-N5 are dimensions for the object as a matrix, with either 0 or 1 for unused dimensions and negative values for ones which are lower triangular, e.g. if there are 50 AO basis functions and 49 linearly independent combinaations, then the lower triangular overlap matrix N1-5 would be “-50 50 0 0 0”, while for the transformation to an orthonormal basis N1-5 would be “50 49 0 0 0”.

IAType gives other information about the matrix. For a real or complex matrix, IAType=1 indicates that the matrix is symmetric/Hermetian and IAType=-1 indicates that it is antisymmetric/anti-Hermetian. For integer arrays, IAType=N>0 indicates that the integers contain a character array with N characters in each element. This allows programs to skip integer arrays which are not of interest in the same way without worrying about whether integer or character data is contained in them.

The end of the file is marked with a record label END with all 0 values for the integers.

Items Stored by Gaussian in a BAF/FAF

1. Header info.
2. Basis function info, all labels can be prefixzed with NEO or Density :
Basis function to atom map
Basis function types
Shell to atom map
Shell Types
Number of primitives per shell
Primitive exponents
Contraction coefficients
P(S=P) Contraction coefficients
Coordinatesa of each shell
3. Pertubation information:
Perturbation frequencies
FD Perturbation scalars
4. ECP info:
ECP-MxAtEC
ECP-MaxLECP
ECP-MaxAtL
ECP-MxTECP
ECP-LenNCZ
ECP-KFirst
ECP-KLast
ECP-LMax
ECP-LPSkip
ECP-RNFroz
ECP-NLP
ECP-CLP
ECP-ZLP
5. Connectivity:
Bonds per atom
Bonded atoms
Bond types
6. ONIOM information:
ONIOM charge/mult
ONIOM atom layers
ONIOM atom modifiers
ONIOM atom types
ONIOM link atoms
ONIOM link charges
ONIOM link distances
7. Symmetry information:
Syminf Integers
RotTr to input orientation
Point Group Irrep Names
Point Group
Point Group Class Names
Point Group Dimensions
Point Group Generators
Point Group Class of Operators
Point Group Rotations
Point Group Cell Trans
Point Group Char Table
Point Group Atom Permutations
8. General Job information:
Title
Route
Info1-9
Method
Basis name
Link0 Commands
Route Parse Results
ILSW
RLSW
Gaussian scalars
9. Misc. atomic variables and parameters:
Optimization flags
Integer Iso
Integer Fragment
Integer Residue
Integer Spin
Integer PDBName
Integer MMPolarizable
Integer MMRefAtom1
Integer MMRefAtom2
Integer MMRefAtom3
Integer MMPolGroup
Real Iso
Real MMCharge
Real ZEffective
Real QuadrupoleMoment
Real GFactor
Real ZNuclear
Real MMXDipole
Real MMYDipole
Real MMZDipole
Real RadNuclear
Real MMXXQuadrupole
Real MMXYQuadrupole
Real MMYYQuadrupole
Real MMXZQuadrupole
Real MMYZQuadrupole
Real MMZZQuadrupole
Real QPolarizability
Real QElectroNegativity
Real QHardness
Real QZeta0
Real QZeta1
Real DEHOMO
Real DPolarizability
Real QPol1
Real MKRadius
Electrons per fragment
Basis functions per fragment
Harm constraint C and FC
10. Computed atomic charges:
Mulliken Charges
ESP Charges
AIM Charges
NPA Charges
APT Charges
MBS Charges
Hirshfeld Charges
CM5 Charges
MBS Mulliken Bond Orders
MBS Mulliken Spin Orders
MBS Mayer Bond Orders
MBS Mayer Lone Pairs
11. Derivatives and related properties:
Nuclear gradient
Nuclear force constants
Nuclear 3rd derivatives
Nuclear 3rd/4th derivatives
Non-adiabatic coupling
Num derivs non-adiabatic coupling
12. Electric and magnetic field derivatives:
Electric Dipole Moment
Electric Dipole Derivatives
Electric Polarizability
Dipole Polarizability Derivatives
HyperPolarizability
Optical Rotation
Optical Rotation Derivatives
DQ Polarizability
DQ Polarizability Derivatives
Quadrupole Moment
Quadrupole Derivatives
Num derivs Dipole Moment
Num derivs Dipole Derivatives
Num derivs Polarizability
Num derivs Polarizability Derivatives
Num derivs HyperPolarizability
Num derivs Optical Rotation
Num derivs Optical Rotation Derivatives
Num derivs DQ Polarizability
Num derivs DQ Polarizability Derivatives
Num derivs Quadrupole Moment
Num derivs Quadrupole Derivatives
Vib MatEl Dipole Moment
Vib MatEl Dipole Derivatives
Vib MatEl Polarizability
Vib MatEl Polarizability Derivatives
Vib MatEl HyperPolarizability
Vib MatEl Optical Rotation
Vib MatEl Optical Rotation Derivatives
Vib MatEl DQ Polarizability
Vib MatEl DQ Polarizability Derivatives
Vib MatEl Quadrupole Moment
Vib MatEl Quadrupole Derivatives
D2 Dipole Moment
D2 Dipole Derivatives
D2 Polarizability
D2 Polarizability Derivatives
D2 HyperPolarizability
D2 Optical Rotation
D2 Optical Rotation Derivatives
D2 DQ Polarizability
D2 DQ Polarizability Derivatives
D2 Quadrupole Moment
D2 Quadrupole Derivatives
Magnetic Susceptability
G-tensor
NMR shielding
Spin-rotation tensors
Anisotropic Hyperfine tensors
Isotropic Hyperfine splittings
ESR G-tensor
QEq coupling tensors
Paramag corr to NMR shielding
Isotropic Spin-Spin Couplings
Num derivs Magnetic Susceptability
Num derivs G-tensor
Num derivs NMR shielding
Num derivs Spin-rotation tensors
Num derivs Anisotropic Hyperfine tensors
Num derivs Isotropic Hyperfine splittings
Num derivs ESR G-tensor
Num derivs QEq coupling tensors
Num derivs Paramag corr to NMR shielding
Num derivs Isotropic Spin-Spin Couplings
Vib MatEl Magnetic Susceptability
Vib MatEl G-tensor
Vib MatEl NMR shielding
Vib MatEl Spin-rotation tensors
Vib MatEl Anisotropic Hyperfine tensors
Vib MatEl Isotropic Hyperfine splittings
Vib MatEl ESR G-tensor
Vib MatEl QEq coupling tensors
Vib MatEl Paramag corr to NMR shielding
Vib MatEl Isotropic Spin-Spin Couplings
Alpha(-w,w)
FD Optical Rotation Tensor
Alpha(w,0)
D-Q polarizability
Beta(-w,w,0)
Beta(w,w,-2w)
Derivative Alpha(-w,w)
Derivative FD Optical Rotation Tensor
Derivative Alpha(w,0)
Derivative D-Q polarizability
Derivative Beta(-w,w,0)
Derivative Beta(w,w,-2w)
D2 Alpha(-w,w)
D2 FD Optical Rotation Tensor
D2 Alpha(w,0)
D2 D-Q polarizability
D2 Beta(-w,w,0)
D2 Beta(w,w,-2w)
13. Vibrational and Rotational Spectroscopy:
Normal mode dimensions
Normal mode flags
Normal mode atomic masses
Normal mode properties
Normal mode components
Anharmonic Normal mode dimensions
Anharmonic Normal mode flags
Anharmonic Normal mode atomic masses
Anharmonic Normal mode properties
Anharmonic Normal mode components
Normal mode Fijj
Quartic Cent Dist
Sextic Cent Dist
14. Post-SCF intermediates:
Mo Transformation window
Windowed orbital energies
Trans MO coefficients
MCSCF parameters
MCSCF Active MOS
MCSCF Active 2PDM
Excited state dims
Excited state spins
Excited state densities
Ground to excited state densities
Excited to excited state densities
SSCIFile integers
SSCIFile reals
PSCF 2PDM
AA MO 2E integrals
AB MO 2E integrals
BA MO 2E integrals
BB MO 2E integrals
15. MM parameters:
MM force field NCPar array
MM force field IPrt array
MM force field ICnvrt array
MM force field ICntr array
MM force field IList array
MM force field IAtL array
MM force field IChL array
MM force field IAType array
MM force field IAtTpT array
MM force field IUserT array
MM force field StepD array
MM force field ICorL array
MM force field SymbT array
MM force field Q array
MM force field RCorL array
MM force field Table array
16. Semi-empirical parameters:
Semi-empirical fixed int params
List of SE elements
Semi-empirical int params
Semi-empirical el-el int params
Semi-empirical fixed real params
Semi-empirical real params
Semi-empirical core params
Semi-empirical el-el real params
Par indices for BEBO
Params for BEBO
17. Internal coordinate information:
Red int coord dims
Red int coord atoms
Red int coord vals
Red int coord iflags
Red int coord rflags
Red int coord constraint
Red int coord names
18. PES information:
Opt energies
Opt reaction coordinate
Opt FMax
Opt FRMS
Opt DXMaxC
Opt DXRMSC
Opt FMaxMM
Opt FRMSMM,
Opt scalars
Opt number of steps
Opt coordinates
Opt gradients
Opt internal coordinates/forces
Rigid Scan energies
Rigid Scan reaction coordinate
Rigid Scan FMax
Rigid Scan FRMS
Rigid Scan DXMaxC
Rigid Scan DXRMSC
Rigid Scan FMaxMM
Rigid Scan FRMSMM,
Rigid Scan scalars
Rigid Scan number of steps
Rigid Scan coordinates
Rigid Scan gradients
Relaxed Scan energies
Relaxed Scan reaction coordinate
Relaxed Scan FMax
Relaxed Scan FRMS
Relaxed Scan DXMaxC
Relaxed Scan DXRMSC
Relaxed Scan FMaxMM
Relaxed Scan FRMSMM,
Relaxed Scan scalars
Relaxed Scan number of steps
Relaxed Scan coordinates
Relaxed Scan gradients
Scan number of steps
Scan variable units
Scan initial values
Scan step sizes
Relaxed Scan internal coordinates/forces
IRC energies
IRC reaction coordinate
IRC FMax
IRC FRMS
IRC DXMaxC
IRC DXRMSC
IRC FMaxMM
IRC FRMSMM,
IRC scalars
IRC number of steps
IRC coordinates
IRC gradients
IRC internal coordinates/forces
Traj energies
Traj reaction coordinate
Traj FMax
Traj FRMS
Traj DXMaxC
Traj DXRMSC
Traj FMaxMM
Traj FRMSMM,
Traj scalars
Traj number of steps
Traj coordinates
Traj gradients
Traj times
Traj kinetic energies
Traj nuclear kinetic energies
Traj potential energies
Traj total angular momentum
Traj electronic kinetic energies
Traj alpha electrons conservation
Traj alpha electrons average idempotency,
Traj alpha electrons rms idempotency
Traj beta electrons conservation
Traj beta electrons average idempotency
Traj beta electrons rms idempotency
Traj moments
Traj unk type scalars
Traj unk type nstep,
Traj unk type results
19. PCM parameters:
PCM integer control parameters
PCM real control parameters
Atomic center of generator spheres
Radii of generator spheres
Centers of generator spheres
Scale factors of generator spheres
Radii of spheres
Centers of spheres
Exposed surface area of spheres
Position of surface elements
Area of surface elements
Sphere index of surface elements
Self-potential factor of surface elements
Self-field factor of surface elements
Charge exponent of surface elements
Normal vector to surface elements
Nuclear potential at surface elements
Electronic potential at surface elements
Total potential at surface elements
Nuclear electric field at surface elements
Total electric field at surface elements
Nuclear apparent charge at surface elements
Total apparent charge at surface charge
PCM_ISlPar
PCM_RSlPar
PCM_LnObj
PCM_ISName
PCM_ITSolv
PCM_NTSolv
PCM_KTPar
PCM_RWPar
PCM_RDPar
PCM_Nord
PCM_IKeepH
PCM_Alpha
PCM_Re0
PCM_Ce0
PCM_GElSph
PCM_DipVac
PCM_DipSol
PCM_QAt2
PCM_ContrA
PCM_Qft1st
PCM_Qfit
PCM_ContrS
PCM_NEord
PCM_AlphNE
PCM_Re0NE
PCM_Ce0NE
PCM_GCvSph
PCM_PCvSph
PCM_GDRSph
PCM_IdCav
PCM_IdDis
PCM_IdRep
PCM_dCav
PCM_dDis
PCM_dRep
PCM_Id2Cav
PCM_Id2Dis
PCM_Id2Rep
PCM_d2Cav
PCM_d2Dis
PCM_d2Rep
20. One-electron operator matrices and related perturbations:
Finite EM field
Overlap
Core Hamiltonian alpha
Core Hamiltonian beta
Kinetic energy
1e Spin-orbit
Orthonormal Basis
Dipole integrals
Quadrupole integrals
Octopole integrals
Hexadecapole integrals
Dip Vel integrals
R X Del integrals
R x Del – Del x R integrals
Dipole derivative integrals
Magnetic Field P1 (GIAO)
NEO Overlap
NEO Core Hamiltonian
NEO Kinetic energy
NEO Orthonormal basis
Alpha Orbital energies
Beta Orbital energies
Alpha MO coefficients
Beta MO coefficients
Alpha Density matrix
Beta Density matrix
SCF Orbital Occupations
Alpha Fock matrix
Beta Fock matrix
Energy-weighted density
SCF Energy-weighted density
NEO Orbital energies
NEO Coefficients
NEO Density
Fragment Density matrices
Fragment Operator matrices
Overlap derivatives
Core Hamiltonian derivatives
F(X)
Density derivatives
MO Fock derivatives
Alpha Ux
Beta Ux
Compressed ST derivatives
Alpha MO derivatives
Beta MO derivatives
Alpha SCF Density matrix
Alpha Psi(1) Density matrix
Alpha MP2 Density,
Alpha MP3 Density matrix
Alpha MP4 Density matrix
Alpha CI Rho(1) Density matrix
Alpha CI Density matrix
Alpha CC Density matrix
Alpha 2nd Order Density matrix
Alpha ONIOM Density matrix
Beta SCF Density matrix
Beta Psi(1) Density matrix
Beta MP2 Density,
Beta MP3 Density matrix
Beta MP4 Density matrix
Beta CI Rho(1) Density matrix
Beta CI Density matrix
Beta CC Density matrix
Beta 2nd Order Density matrix
Beta ONIOM Density matrix
Alpha OAO density matrix
Beta OAO density matrix
Alpha OAO Fock matrix
Beta OAO Fock matrix
Fock Util Parameters
Fock Util Densities
Fock Util Scalar Results
Fock Util Results
GIAO D2H/DBDM
GIAO L/R3
GIAO VCD <dMu/dX|dNu/dB>
GIAO VCD <Mu|dNu/dB>
3d Quadrature Grid
21. PBC information:
NBFU for each K-point
K-point Miller Indices
K-point Phases
K-point Factors
K-point Weights
PBC Orbital Eneries
PBC Orbital Weights
PBC Alpha Orbitals
PBC Beta Orbitals
22. RWF file contents by file number.
23. 2E quantities:
Regular 2E integrals
Raffenetti 2E integrals
PBC 2E integrals
2E AO integral nuclear derivatives
NBT to AO Indexing
NBT 2e Integrals

You can download the Gaussian interfacing package here (gaussian.com/g16/gauopen_v2.zip). This is version 2 for Rev B.01; see the note for Rev A.03 below. You may need to right-click on the link to save the file in some browser configurations.

You can download the precompiled shared libraries for Python interface here (gaussian.com/g16/gauopen_v2-so.zip).

Once you unzip the archive, the resulting gauopen folder will contain descriptions of the structure of the interface files, the procedures for using them, open source code for use in interfacing, and example programs which illustrate the interfaces.

General documentation about the interfaces:

  • interface.txt: Description of the interfacing methods and examples.
  • unfdat.txt: Description of the matrix element file, which provides the basic interface between Gaussian and other programs.
  • LICENSE.txt: Modified version of the Mozilla open source license, which applies to all files in the directory.

Routines which provide access to the files in various languages. Details about the objects, methods, and calling sequences are in the comments in each file:

  • qcmatrixio.F: Low-level Fortran routines to read and write the matrix element file, used by both the Fortran and Python interfaces.
  • qcmatrix.F: Higher-level interfacing routines for use in Fortran programs.
  • QCMatEl.py, QCOpMat.py: Python object-oriented interface. QCOpMat.py provides an operator matrix object class for individual operator objects in the file, and QMatEl.py provides a class for the complete data file to matrix element files. Both of these use f2py to wrap the low-level Fortran routines and work with the Fortran unformatted version of the matrix element file. The matrix element file class also provides for running a Gaussian job to populate a matrix element object with additional data. Details on the objects and methods are in the comments in the files.
  • MatEl.pm, OpMat.pm, GauComplex.pm: Modules which provide a Perl object-oriented interface to matrix element files. These do raw C-style read and write calls to the file and work with the raw binary form of the matrix element file.
  • qc.make: Makefile which compiles the Fortran and Python interfaces and the example programs. In interface version 2, qc.makee tries to set the correct .so file name if Python 3.6 rather than 3.4 is used.

Example programs and scripts:

  • readmat.F, readmat.py, readmat.pl: Simple programs to read a matrix element file and print the contents.
  • writemat.F, writemat.py, writemat.pl: Simple programs which use internally stored data to create a matrix element file.
  • domp2.F, domp2.py, domp2.pl: Recover orbital energies and MO integrals from the file and compute the MP2 energy.
  • f2o2a.gjf, f2o2b.gjf, f2o2c.gjf, f2o2d.gjf, f2o2e.gjf, f2o2.gjf: Input files for Gaussian to produce matrix element files read by the domp2 examples.
  • pyquante2-interface.py: A replacement for the one and two electron integral modules in the PyQuante2’s program which generates a minimal matrix element file from PyQuante2 data on a molecule. It runs Gaussian to add one and two electron integrals to the file, and then returns the integrals in the form used by PyQuante2.

Python library file name utility:

  • cksoname: Python library file names vary considerably between Python 3.4 and 3.6, between different hardware/operating system environments, and according to the exact installation method used to install the software. This script tries to find a .so in the Python tree in order to display what a typical name looks like for the local installation. You will need to name the provided gauopen shared object file to conform to the convention in use.

Using the Current Files with Rev A.03

The files in the download archive will work normally with Rev A.03 with one exception. When running Gaussian from Python, if you use any of the methods for a matrix element file object in order to update the matrix element file and run Gaussian—i.e., the usual method update() or the underlying rungau() or makegauinp() methods—then you need to add the Python keyword argument revision=”a03″ when invoking the method in order to have it generate the input file required for Rev A.03, rather than using the command-line options mechanism introduced in Rev B.01 which is now the default. You can also download the Rev A.03 build of version 1 of the interface files here.

Changes in gauopen version 3.11:

qcmatrixio.F and qcmatrixioc.c:

  • Changes to handle 2e integrals from PBC.
  • Compiled pack and unpack routines for 2e integrals callable from Python.
  • Fixes for handling general character strings in OpMat objects.

Python interface:

  • Classes were split up:
    a. OpMat — general array objects not specific to quantum chemistry
    b. QCOpMat — inherits from OpMat and provides methods related to quantum chemistry.
    c. BinArFile — general collection of array objects / file almost not pecific to quantum chemistry. The only QC-specific data is the molecule-related information in the header records of the file, all of which can be ignored for files with data unrelated to a molecule.
    d. QCBinAr — inherits from BinArFile and provides methods related to quantum chemistry in general and running Gaussian in particular.
    e. Python wrappers for low-level routines in qcmatrixio.F and qcmatrixeioc.c which do basic I/O from disk files. Has nothing specifc to quantum chemistry.
    f. QCUtil — classes and routines specific to quantum chemistry which provide functionality for QCBinAr and QCOpMat.
    g. QCUtilH — higher level routines which work on QCBinAr and QCOpMt objects to provide functionality for quantum chemistry. The routines which formerly were in SCFUtil.py are now in this file.
  • Added methods in QCBinAr/BinArFile which are of general interest:
    a. merge — merges contents of one baf into another.
    b. movobj — moves or copies one OpMat object from one baf to another.
    c. run_cubegen — runs cubegen to evaluate volumetric data which is added to the baf object.
  • Added methods in QCOpMat/OpMat which are of general interest:
    a. isnumer, isstring — properties indicating whether numeric or character data is stored in the object.
    b. string — property which returns the character data in the object as a single string, regardless of whether it is stored as a single string or an array of strings.
    c. charsplit — takes string data in an object and converts it to an array of strings in accord with the typea value.
  • All Python objects and routines are documented using doxygen. html documentation can be found in gauopen/docs/python/build/html/index.html and a plain text version can be found in gauopen/gauopen_python.txt.

New or improved examples:

  • dumpfile.gjf, dumpfile.py — illustrates how to get the contents of an arbitrary file in the Gaussian rwf into a baf.
  • scf.py now illustrates how to form a Fock matrix either by calling Gaussian or using 2e integrals from the baf.

Changes in gauopen version 2.0:

General:

  • Matrix Element files renamed to Binary Array files (BAF)
  • Standard extensions changed from .mat to .faf (for Fortran formatted files) and .baf (for c formatted files)
  • BAF file format now support arrays of character data
  • Makefile supports Windows/MacOS/Linux machines

Python:

  • QCMatEl.py renamed to QCBinAr.py and QCMatEl.MatEl renamed to QCBinAr.BinAr
  • python interface now available as python sdist and wheels installable through pip
  • gauopen wheels require no Fortran/C compilers
  • compatibility with python 3.5 – 3.10 (3.6 – 3.10 for Windows)
  • Windows support for Python interface
  • Support for reading/writing 8 byte Fortran formatted files and 4/8 C formatted files.
  • New BinAr class methods, readfile and writefile, to read from/write to checkpoint files (chk), formatted checkpoint files (fchk), gaussian job files (com/gjf), and any format supported by newzmat
  • Numpy arrays can be added/deleted from BinAr.matlist directly
  • Binary array files can be converted between Fortran/c and 8/4 byte integer sizes directly
  • Ability to extract intermediate geometries/energies (QCBinAr.BinAr.expand_traj()) from Gaussian jobs containing trajectory data (optimization, scan)
  • Ability to extract vibrational properties (QCBinAr.BinAr.expand_freq()) from Gaussian jobs containing frequency data
  • Gaussian log file can be monitored while Gaussian jobs are run from python interface
  • Additional job options for running Gaussian jobs from interface (update(), rungau())
  • Gaussian compute parameters can be set (and error checked) for Gaussian jobs run from python interface
  • Flexible install where only Fortran or c low-level modules are required for operation for compatibility with systems where no Fortran or c compiler is available
  • full documentation of python interface functions/classes
  • python tests now included
  • iopcl/icgu conversions handled automatically
  • Object printing compatible with ipython/jupyter printing

C:

  • new c interface routines to read/write c-style binary array files
  • feature parity with Fortran routines
  • Higher level interface routines to interact with Binary array files as object-like structures

Changes in gauopen version 2:

  • __version__ set in python modules.
  • qc.make now tries to set correct .so file names if python 3.6 rather than 3.4 is used.
  • problems in returning arrays holding complex numbers in python interface fixed.
  • a problem in writing a matrix element file from python when the object contained 2e integrals was fixed.
  • precompiled shared libraries for python interface provided, so that this can be used without needing a fortran compiler.

Gaussian Interface Code Open-Source Public License, v. 1.0

Based on the Mozilla Public License version 2.0

1. Definitions

1.1. “CONTRIBUTOR” means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software.

1.2. “CONTRIBUTION” means Covered Software of a particular CONTRIBUTOR.

1.3. “CONTRIBUTOR VERSION” means the combination of the CONTRIBUTIONS of others (if any) used by a CONTRIBUTOR and that particular CONTRIBUTOR’s Contribution.

1.4. “COVERED SOFTWARE” means Source Code Form to which the initial CONTRIBUTOR has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof.

1.5. “EXECUTABLE FORM” means any form of the work other than Source Code Form.

1.6. “LARGER WORK” means a work that combines COVERED SOFTWARE with other material, in a separate file or files, that is not COVERED SOFTWARE.

1.7. “LICENSE” means this document.

1.8. “LICENSABLE” means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this LICENSE.

1.9. “MODIFICATIONS” means any of the following:

  1. Any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or
  2. Any new file in Source Code Form that contains any COVERED SOFTWARE.

1.10. “PATENT CLAIMS” of a CONTRIBUTOR means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent LICENSABLE by such CONTRIBUTOR that would be infringed, but for the grant of the LICENSE, by the making, using, selling, offering for sale, having made, import, or transfer of either its CONTRIBUTIONS or its CONTRIBUTOR VERSION.

1.11. “SOURCE CODE FORM” means the form of the work preferred for making modifications.

1.12. “YOU” (OR “YOUR”) means an individual or a legal entity exercising rights under this LICENSE. For legal entities, “YOU” includes any entity that controls, is controlled by, or is under common control with YOU. For purposes of this definition, “control” means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.

2. License Grants and Conditions

2.1. Grants: Each CONTRIBUTOR hereby grants YOU a world-wide, royalty-free, non-exclusive license:

  1. Under intellectual property rights (other than patent or trademark) LICENSABLE by such CONTRIBUTOR to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its CONTRIBUTIONS, either on an unmodified basis, with MODIFICATIONS, or as part of a LARGER WORK; and
  2. Under PATENT CLAIMS of such CONTRIBUTOR to make, use, sell, offer for sale, have made, import, and otherwise transfer either its CONTRIBUTIONS or its CONTRIBUTOR VERSION.

2.2. Effective Date: The licenses granted in Section 2.1 with respect to any CONTRIBUTION become effective for each CONTRIBUTION on the date the CONTRIBUTOR first distributes such CONTRIBUTION.

2.3. Limitations on Grant Scope: The licenses granted in this Section 2 are the only rights granted under this LICENSE. No additional rights or licenses will be implied from the distribution or licensing of COVERED SOFTWARE under this LICENSE. Notwithstanding Section 2.1(1) above, no patent license is granted by a CONTRIBUTOR:

  1. For any code that a CONTRIBUTOR has removed from COVERED SOFTWARE; or
  2. For infringements caused by: (i) YOUR and any other third party’s modifications of COVERED SOFTWARE, or (ii) the combination of its CONTRIBUTIONS with other software (except as part of its CONTRIBUTOR Version); or
  3. Under PATENT CLAIMS infringed by COVERED SOFTWARE in the absence of its CONTRIBUTIONS.

This LICENSE does not grant any rights in the trademarks, service marks, or logos of Gaussian, Inc. or any CONTRIBUTOR (except as may be necessary to comply with the notice requirements in Section 3.4).

2.4. Representation: Each CONTRIBUTOR represents that the CONTRIBUTOR believes its CONTRIBUTIONS are its original creation(s) or it has sufficient rights to grant the rights to its CONTRIBUTIONS conveyed by this LICENSE.

2.5. Fair Use: This License is not intended to limit any rights YOU have under applicable copyright doctrines of fair use, fair dealing, or other equivalents.

2.6. Conditions: Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1.

3. Responsibilities

3.1. Distribution of Source Form: All distribution of COVERED SOFTWARE in SOURCE CODE FORM, including any MODIFICATIONS that YOU create or to which YOU contribute, must be under the terms of this License. YOU must inform recipients that the SOURCE CODE FORM of the COVERED SOFTWARE is governed by the terms of this License, and how they can obtain a copy of this License. YOU may not attempt to alter or restrict the recipients’ rights in the SOURCE CODE FORM.

3.2. Distribution of EXECUTABLE FORM: If YOU distribute COVERED SOFTWARE in EXECUTABLE FORM, including any MODIFICATIONS that YOU create or to which YOU contribute, then:

  1. Such COVERED SOFTWARE must also be made available in Source Code Form, as described in Section 3.1, and YOU must inform recipients of the EXECUTABLE FORM how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and
  2. YOU may distribute such EXECUTABLE FORM under the terms of this License, or sublicense it under different terms, provided that the license for the EXECUTABLE FORM does not attempt to limit or alter the recipients’ rights in the SOURCE CODE FORM, including any MODIFICATIONS that YOU create or to which YOU contribute, under this License.

3.3. Notices: YOU may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the SOURCE CODE FORM of the COVERED SOFTWARE, except that YOU may alter any license notices to the extent required to remedy known factual inaccuracies.

3.4. Application of Additional Terms: YOU may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of COVERED SOFTWARE. However, YOU may do so only on YOUR own behalf, and not on behalf of any CONTRIBUTOR. YOU must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by YOU alone, and YOU hereby agree to indemnify every CONTRIBUTOR for any liability incurred by such CONTRIBUTOR as a result of warranty, support, indemnity or liability terms YOU offer. YOU may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction.

4. Inability to Comply Due to Statute or Regulation

If it is impossible for YOU to comply with any of the terms of this License with respect to some or all of the COVERED SOFTWARE due to statute, judicial order, or regulation then YOU must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the COVERED SOFTWARE under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.

5. Termination

5.1. The rights granted under this License will terminate automatically if YOU fail to comply with any of its terms. However, if YOU become compliant, then the rights granted under this License from a particular CONTRIBUTOR are reinstated (a) provisionally, unless and until such CONTRIBUTOR explicitly and finally terminates YOUR grants, and (b) on an ongoing basis, if such CONTRIBUTOR fails to notify YOU of the non-compliance by some reasonable means prior to 60 days after YOU have come back into compliance. Moreover, YOUR grants from a particular CONTRIBUTOR are reinstated on an ongoing basis if such CONTRIBUTOR notifies YOU of the non-compliance by some reasonable means, this is the first time YOU have received notice of non-compliance with this License from such CONTRIBUTOR, and YOU become compliant prior to 30 days after YOUR receipt of the notice.

5.2. If YOU initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a CONTRIBUTOR VERSION directly or indirectly infringes any patent, then the rights granted to YOU by any and all CONTRIBUTORs for the COVERED SOFTWARE under Section 2.1 of this License shall terminate.

5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by YOU or YOUR distributors under this License prior to termination shall survive termination.

6. Disclaimer of Warranty

COVERED SOFTWARE is provided under this License on an “as is” basis, without warranty of any kind, either expressed, implied, or statutory, including, without limitation, warranties that the COVERED SOFTWARE is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the COVERED SOFTWARE is with YOU. Should any COVERED SOFTWARE prove defective in any respect, YOU (not any CONTRIBUTOR) assume the cost of any necessary servicing, repair, or correction. This disclaimer of warranty constitutes an essential part of this License. No use of any COVERED SOFTWARE is authorized under this License except under this disclaimer.

7. Limitation of Liability

Under no circumstances and under no legal theory, whether tort (including negligence), contract, or otherwise, shall any CONTRIBUTOR, or anyone who distributes COVERED SOFTWARE as permitted above, be liable to YOU for any direct, indirect, special, incidental, or consequential damages of any character including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if such party shall have been informed of the possibility of such damages. This limitation of liability shall not apply to liability for death or personal injury resulting from such party’s negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to YOU.

8. Litigation

Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party’s ability to bring cross-claims or counter-claims.

9. Miscellaneous

This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a CONTRIBUTOR.

10. Versions of the License

This is the sole applicable version of this License. It is a modification of the Mozilla Public License version 2.0, but the Mozilla Foundation is not responsible for this version of the license and no modifications made to the Mozilla Public License apply to this contract.

Exhibit A – SOURCE CODE FORM License Notice

This source code is subject to the terms of the Gaussian Interface Code Public License, v. 1.0. A copy of this license should have been distributed with this file, but is also available on the Gaussian website, https://gaussian.com/public-licensev1.0.

If it is not possible or desirable to put the notice in a particular file, then YOU may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice.

SideMenu

SideMenu