GauOpen: Interfacing to Gaussian 26 (v3)
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.
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:
- Any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or
- 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:
- 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
- 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:
- For any code that a CONTRIBUTOR has removed from COVERED SOFTWARE; or
- 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
- 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:
- 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
- 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.
