diff --git a/gaussianparser.egg-info/PKG-INFO b/gaussianparser.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..fededd0995d5bce642607a72ab553faa47b3fc64 --- /dev/null +++ b/gaussianparser.egg-info/PKG-INFO @@ -0,0 +1,10 @@ +Metadata-Version: 1.0 +Name: gaussianparser +Version: 0.1 +Summary: NOMAD parser implementation for Gaussian. +Home-page: UNKNOWN +Author: UNKNOWN +Author-email: UNKNOWN +License: APACHE 2.0 +Description: UNKNOWN +Platform: UNKNOWN diff --git a/gaussianparser.egg-info/SOURCES.txt b/gaussianparser.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..a86e53234caa7692a38c296635c87712c0f60166 --- /dev/null +++ b/gaussianparser.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +./gaussianparser/__init__.py +./gaussianparser/parser_gaussian.py +./gaussianparser/setup_paths.py +./gaussianparser.egg-info/PKG-INFO +./gaussianparser.egg-info/SOURCES.txt +./gaussianparser.egg-info/dependency_links.txt +./gaussianparser.egg-info/requires.txt +./gaussianparser.egg-info/top_level.txt \ No newline at end of file diff --git a/gaussianparser.egg-info/dependency_links.txt b/gaussianparser.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/gaussianparser.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/gaussianparser.egg-info/requires.txt b/gaussianparser.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..f23d3478b1b70b8eab22077805184aa208d1876e --- /dev/null +++ b/gaussianparser.egg-info/requires.txt @@ -0,0 +1 @@ +nomadcore diff --git a/gaussianparser.egg-info/top_level.txt b/gaussianparser.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..47aa064c00040a5c444be80cf737744729527060 --- /dev/null +++ b/gaussianparser.egg-info/top_level.txt @@ -0,0 +1 @@ +gaussianparser diff --git a/gaussianparser/__init__.py b/gaussianparser/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4074e8bafff2cbd79fd5132ab1014bbef28fb038 --- /dev/null +++ b/gaussianparser/__init__.py @@ -0,0 +1 @@ +from gaussianparser.parser_gaussian import GaussianParser diff --git a/gaussianparser/parser_gaussian.py b/gaussianparser/parser_gaussian.py new file mode 100644 index 0000000000000000000000000000000000000000..655fd3633517006f181966a269240ac44cfda6af --- /dev/null +++ b/gaussianparser/parser_gaussian.py @@ -0,0 +1,1569 @@ +# Copyright 2015-2018 Rosendo Valero, Fawzi Mohamed, Ankit Kariryaa +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import division +from builtins import str +from builtins import range +from builtins import object +from functools import reduce +from nomadcore.simple_parser import mainFunction, SimpleMatcher as SM +from nomadcore.local_meta_info import loadJsonFile, InfoKindEl +from nomadcore.caching_backend import CachingLevel +from nomadcore.unit_conversion.unit_conversion import convert_unit +import os, sys, json, logging +import numpy as np +import ase +import re + +############################################################ +# This is the parser for the output file of Gaussian. +############################################################ + +logger = logging.getLogger("nomad.GaussianParser") + +# description of the output +mainFileDescription = SM( + name = 'root', + weak = True, + forwardMatch = True, + startReStr = "", + subMatchers = [ + SM(name = 'newRun', + startReStr = r"\s*Cite this work as:", + repeats = True, + required = True, + forwardMatch = True, + fixedStartValues={ 'program_name': 'Gaussian', 'program_basis_set_type': 'gaussians' }, + sections = ['section_run', 'section_system'], + subMatchers = [ + SM(name = 'header', + startReStr = r"\s*Cite this work as:", + forwardMatch = True, + subMatchers = [ + SM(r"\s*Cite this work as:"), + SM(r"\s*Gaussian [0-9]+, Revision [A-Za-z0-9.]*,"), + SM(r"\s\*\*\*\*\*\*\*\*\*\*\*\**"), + SM(r"\s*Gaussian\s*(?P[0-9]+):\s*(?P[A-Za-z0-9-.]+)\s*(?P[0-9][0-9]?\-[A-Z][a-z][a-z]\-[0-9]+)"), + SM(r"\s*(?P[0-9][0-9]?\-[A-Z][a-z][a-z]\-[0-9]+)"), + ] + ), + SM(name = 'globalparams', + startReStr = r"\s*%\w*=", + subFlags = SM.SubFlags.Unordered, + forwardMatch = True, + subMatchers = [ + SM(r"\s*%[Cc]hk=(?P[A-Za-z0-9.]*)"), + SM(r"\s*%[Mm]em=(?P[A-Za-z0-9.]*)"), + SM(r"\s*%[Nn][Pp]roc=(?P[A-Za-z0-9.]*)") + ] + ), + SM (name = 'SectionMethod', + sections = ['section_method'], + startReStr = r"\s*#", + forwardMatch = True, + subMatchers = [ + SM(r"\s*(?P([a-zA-Z0-9-/=(),#*+:]*\s*)+)"), + SM(r"\s*(?P([a-zA-Z0-9-/=(),#*+:]*\s*)+)"), + ] + ), + SM(name = 'charge_multiplicity_cell_masses', + startReStr = r"\s*Charge =", + endReStr = r"\s*Leave Link 101\s*", + subFlags = SM.SubFlags.Unordered, + forwardMatch = True, + subMatchers = [ + SM(r"\s*Charge =\s*(?P[-+0-9]*) Multiplicity =\s*(?P[0-9]*)"), + SM(r"\s*(Tv|Tv\s*[0]|TV|TV\s*[0])\s*(?P[0-9.]+)\s+(?P[0-9.]+)\s+(?P[0-9.]+)", repeats = True), + SM(r"\s*AtmWgt=\s+(?P[0-9.]+(\s+[0-9.]+)(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?(\s+[0-9.]+)?)", repeats = True) + ] + ), + SM (name = 'SingleConfigurationCalculationWithSystemDescription', + startReStr = "\s*Standard orientation:", + repeats = False, + forwardMatch = True, + subMatchers = [ + SM (name = 'SingleConfigurationCalculation', + startReStr = "\s*Standard orientation:", + repeats = True, + forwardMatch = True, + sections = ['section_single_configuration_calculation'], + subMatchers = [ + SM(name = 'geometry', + sections = ['x_gaussian_section_geometry'], + startReStr = r"\s*Standard orientation:", + endReStr = r"\s*Rotational constants", + subMatchers = [ + SM(r"\s+[0-9]+\s+(?P[0-9]+)\s+[0-9]*\s+(?P[-+0-9EeDd.]+)\s+(?P[-+0-9EeDd.]+)\s+(?P[-+0-9EeDd.]+)",repeats = True), + SM(r"\s*Rotational constants") + ] + ), + SM(name = 'SectionHybridCoeffs', + sections = ['x_gaussian_section_hybrid_coeffs'], + startReStr = r"\s*IExCor=", + forwardMatch = True, + subMatchers = [ + SM(r"\s*IExCor=\s*[0-9-]+\s*DFT=[A-Z]\s*Ex\+Corr=[a-zA-Z0-9]+\s*ExCW=[0-9]\s*ScaHFX=\s*(?P[0-9.]+)"), + SM(r"\s*IExCor=\s*[0-9-]+\s*DFT=[A-Z]\s*Ex\=[a-zA-Z0-9+]+\s*Corr=[ a-zA-Z0-9]+\s*?ExCW=[0-9]\s*ScaHFX=\s*(?P[0-9.]+)"), + SM(r"\s*IExCor=\s*[0-9-]+\s*DFT=[A-Z]\s*Ex\=[a-zA-Z0-9+]+\s*Corr=[ a-zA-Z0-9]+\s*ScaHFX=\s*(?P[0-9.]+)"), + SM(r"\s*ScaDFX=\s*(?P[0-9.]+\s*[0-9.]+\s*[0-9.]+\s*[0-9.]+)") + ] + ), + SM(name = 'TotalEnergyScfGaussian', + sections = ['section_scf_iteration'], + startReStr = r"\s*Requested convergence on RMS", + forwardMatch = False, + repeats = True, + subMatchers = [ + SM(r"\s*Cycle\s+[0-9]+|\s*Initial guess ="), + SM(r"\s*E=\s*(?P[-+0-9.]+)\s*Delta-E=\s*(?P[-+0-9.]+)"), + SM(r"\s*(?PSCF Done):\s*E\((?P[A-Z0-9]+)\)\s*=\s*(?P[-+0-9.]+)"), + SM(r"\s*NFock=\s*[0-9]+\s*Conv=(?P[-+0-9EeDd.]+)\s*"), + SM(r"\s*KE=\s*(?P[-+0-9EeDd.]+)\s*"), + SM(r"\s*Annihilation of the first spin contaminant"), + SM(r"\s*[A-Z][*][*][0-9]\s*before annihilation\s*(?P[0-9.]+),\s*after\s*(?P[0-9.]+)"), + SM(r"\s*[()A-Z0-9]+\s*=\s*[-+0-9D.]+\s*[()A-Z0-9]+\s*=\s*(?P[-+0-9D.]+)"), + ] + ), + SM(name = 'PerturbationEnergies', + sections = ['x_gaussian_section_moller_plesset'], + startReStr = r"\s*E2 =\s*", + forwardMatch = True, + subMatchers = [ + SM(r"\s*E2 =\s*(?P[-+0-9EeDd.]+)\s*EUMP2 =\s*(?P[-+0-9EeDd.]+)"), + SM(r"\s*E3=\s*(?P[-+0-9EeDd.]+)\s*EUMP3=\s*(?P[-+0-9EeDd.]+)\s*"), + SM(r"\s*E4\(DQ\)=\s*(?P[-+0-9EeDd.]+)\s*UMP4\(DQ\)=\s*(?P[-+0-9EeDd.]+)\s*"), + SM(r"\s*E4\(SDQ\)=\s*(?P[-+0-9EeDd.]+)\s*UMP4\(SDQ\)=\s*(?P[-+0-9EeDd.]+)"), + SM(r"\s*E4\(SDTQ\)=\s*(?P[-+0-9EeDd.]+)\s*UMP4\(SDTQ\)=\s*(?P[-+0-9EeDd.]+)"), + SM(r"\s*DEMP5 =\s*(?P[-+0-9EeDd.]+)\s*MP5 =\s*(?P[-+0-9EeDd.]+)"), + ] + ), + SM(name = 'CoupledClusterEnergies', + sections = ['x_gaussian_section_coupled_cluster'], + startReStr = r"\s*CCSD\(T\)\s*", + endReStr = r"\s*Population analysis using the SCF density", + forwardMatch = True, + subMatchers = [ + SM(r"\s*DE\(Corr\)=\s*(?P[-+0-9EeDd.]+)\s*E\(CORR\)=\s*(?P[-+0-9EeDd.]+)", repeats = True), + SM(r"\s*CCSD\(T\)=\s*(?P[-+0-9EeDd.]+)"), + ] + ), + SM(name = 'QuadraticCIEnergies', + sections = ['x_gaussian_section_quadratic_ci'], + startReStr = r"\s*Quadratic Configuration Interaction\s*", + endReStr = r"\s*Population analysis using the SCF density", + forwardMatch = True, + subMatchers = [ + SM(r"\s*DE\(Z\)=\s*(?P[-+0-9EeDd.]+)\s*E\(Z\)=\s*(?P[-+0-9EeDd.]+)", repeats = True), + SM(r"\s*DE\(Corr\)=\s*(?P[-+0-9EeDd.]+)\s*E\(CORR\)=\s*(?P[-+0-9EeDd.]+)", repeats = True), + SM(r"\s*QCISD\(T\)=\s*(?P[-+0-9EeDd.]+)"), + SM(r"\s*DE5\s*=\s*(?P[-+0-9EeDd.]+)\s*QCISD\(TQ\)\s*=\s*(?P[-+0-9EeDd.]+)", repeats = True), + ] + ), + SM(name = 'CIEnergies', + sections = ['x_gaussian_section_ci'], + startReStr = r"\s*Configuration Interaction\s*", + endReStr = r"\s*Population analysis using the SCF density", + forwardMatch = True, + subMatchers = [ + SM(r"\s*DE\(CI\)=\s*(?P[-+0-9EeDd.]+)\s*E\(CI\)=\s*(?P[-+0-9EeDd.]+)", repeats = True), + ] + ), + SM(name = 'SemiempiricalEnergies', + sections = ['x_gaussian_section_semiempirical'], + startReStr = r"\s*[-A-Z0-9]+\s*calculation of energy[a-zA-Z,. ]+\s*", + endReStr = r"\s*Population analysis using the SCF density", + forwardMatch = True, + subMatchers = [ + SM(r"\s*(?P[-A-Z0-9]+\s*calculation of energy[a-zA-Z,. ]+)"), + SM(r"\s*It=\s*[0-9]+\s*PL=\s*[-+0-9EeDd.]+\s*DiagD=[A-Z]\s*ESCF=\s*(?P[-+0-9.]+)\s*", repeats = True), + SM(r"\s*Energy=\s*(?P[-+0-9EeDd.]+)"), + ] + ), + SM(name = 'MolecularMechanicsEnergies', + sections = ['x_gaussian_section_molmech'], + startReStr = r"\s*[-A-Z0-9]+\s*calculation of energy[a-zA-Z,. ]+\s*", + forwardMatch = False, + repeats = True, + subMatchers = [ + SM(r"\s*(?P[a-zA-Z0-9]+\s*calculation of energy[a-z,. ]+)"), + SM(r"\s*Energy=\s*(?P[-+0-9EeDd.]+)\s*NIter=\s*[0-9.]"), + ] + ), + SM(name = 'ExcitedStates', + sections = ['x_gaussian_section_excited_initial'], + startReStr = r"\s*Excitation energies and oscillator strengths", + forwardMatch = False, + repeats = True, + subMatchers = [ + SM(name = 'ExcitedStates', + sections = ['x_gaussian_section_excited'], + startReStr = r"\s*Excited State", + forwardMatch = False, + repeats = True, + subMatchers = [ + SM(r"\s*Excited State\s*(?P[0-9]+):\s*[-+0-9A-Za-z.\?]+\s*(?P[0-9.]+)\s*eV\s*[0-9.]+\s*nm\s*f=(?P[0-9.]+)\s*<[A-Z][*][*][0-9]>=(?P[0-9.]+)"), + SM(r"\s*(?P[0-9A-Z]+\s*->\s*[0-9A-Z]+\s*[-+0-9.]+)", repeats = True), + SM(r"\s*This state for optimization|\r?\n"), + ] + ) + ] + ), + SM(name = 'CASSCFStates', + sections = ['x_gaussian_section_casscf'], + startReStr = r"\s*EIGENVALUES AND\s*", + forwardMatch = True, + repeats = False, + subMatchers = [ + SM(r"\s*EIGENVALUES AND\s*"), + SM(r"\s*\(\s*[0-9]+\)\s*EIGENVALUE\s*(?P[-+0-9.]+)", repeats = True), + ] + ), + SM(name = 'Geometry_optimization', + sections = ['x_gaussian_section_geometry_optimization_info'], + startReStr = r"\s*Optimization completed.", + forwardMatch = True, + subMatchers = [ + SM(r"\s*(?POptimization completed)"), + SM(r"\s*(?POptimization stopped)"), + SM(r"\s+[0-9]+\s+[0-9]+\s+[0-9]+\s+[-+0-9EeDd.]+\s+[-+0-9EeDd.]+\s+[-+0-9EeDd.]+",repeats = True), + SM(r"\s*Distance matrix|\s*Rotational constants|\s*Stoichiometry") + ] + ), + SM(name = 'Orbital symmetries', + sections = ['x_gaussian_section_orbital_symmetries'], + startReStr = r"\s+Population analysis", + subFlags = SM.SubFlags.Sequenced, + subMatchers = [ + SM(r"\s*Orbital symmetries"), + SM(r"\s*Alpha Orbitals"), + SM(r"\s*Occupied\s+(?P\((.+)\))?"), + SM(r"\s+(?P\((.+)\)?)", repeats = True), + SM(r"\s*Virtual\s+(?P\((.+)\))?"), + SM(r"\s+(?P\((.+)\)?)", repeats = True), + SM(r"\s*Beta Orbitals"), + SM(r"\s*Occupied\s+(?P\((.+)\))?"), + SM(r"\s+(?P\((.+)\)?)", repeats = True), + SM(r"\s*Virtual\s+(?P\((.+)\))?"), + SM(r"\s+(?P\((.+)\)?)", repeats = True), + ] + ), + SM(name = 'Electronicstatesymmetry', + sections = ['x_gaussian_section_symmetry'], + startReStr = r"\s*The electronic state is", + forwardMatch = True, + subMatchers = [ + SM(r"\s*The electronic state is\s*(?P[A-Z0-9-']+)[.]") + ] + ), + SM(name = 'Eigenvalues', + sections = ['section_eigenvalues'], + startReStr = r"\s*Alpha occ. eigenvalues --", + forwardMatch = True, + subFlags = SM.SubFlags.Sequenced, + subMatchers = [ + SM(r"\s*Alpha occ. eigenvalues --\s+(?P-?[^\s.-]+\s+|(\-?\d*\.\d*)\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?)", repeats = True), + SM(r"\s*Alpha virt. eigenvalues --\s+(?P-?[^\s.-]+\s+|(\-?\d*\.\d*)\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?)", repeats = True), + SM(r"\s*Beta occ. eigenvalues --\s+(?P-?[^\s.-]+\s+|(\-?\d*\.\d*)\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?)", repeats = True), + SM(r"\s*Beta virt. eigenvalues --\s+(?P-?[^\s.-]+\s+|(\-?\d*\.\d*)\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?\s+(\-?\d*\.\d*)?)", repeats = True), + SM(r"\s*- Condensed to atoms (all electrons)"), + ] + ), + SM(name = 'ForcesGaussian', + sections = ['x_gaussian_section_atom_forces'], + startReStr = "\s*Center\s+Atomic\s+Forces ", + forwardMatch = True, + subMatchers = [ + SM(r"\s*Center\s+Atomic\s+Forces "), + SM(r"\s+[0-9]+\s+[0-9]+\s+(?P[-+0-9EeDd.]+)\s+(?P[-+0-9EeDd.]+)\s+(?P[-+0-9EeDd.]+)",repeats = True), + SM(r"\s*Cartesian Forces:\s+") + ] + ), + SM(name = 'Multipoles', + sections = ['x_gaussian_section_molecular_multipoles'], + startReStr = r"\s*Electronic spatial extent", + forwardMatch = False, + subMatchers = [ + SM(r"\s*Charge=(?P\s*[-0-9.]+)"), + SM(r"\s*Dipole moment "), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s*Quadrupole moment"), + SM(r"\s+\w+=\s+(?P[0-9-.]+)\s+\w+=\s+(?P[0-9-.]+)\s+\w+=\s+(?P[0-9-.]+)"), + SM(r"\s+\w+=\s+(?P[0-9-.]+)\s+\w+=\s+(?P[0-9-.]+)\s+\w+=\s+(?P[0-9-.]+)"), + SM(r"\s*Traceless Quadrupole moment"), + SM(r"\s+\w+=\s+[0-9-.]+\s+\w+=\s+[0-9-.]+\s+\w+=\s+[0-9-.]+"), + SM(r"\s+\w+=\s+[0-9-.]+\s+\w+=\s+[0-9-.]+\s+\w+=\s+[0-9-.]+"), + SM(r"\s*Octapole moment"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s*Hexadecapole moment"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)"), + SM(r"\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)\s+\w+=\s+(?P[-+0-9EeDd.]+)") + ] + ), + SM (name = 'Frequencies', + sections = ['x_gaussian_section_frequencies'], + startReStr = r"\s*Frequencies --\s+(?:(?:[-]?[0-9]+\.\d*)\s*(?:[-]?[-0-9]+\.\d*)?\s*(?:[-]?[-0-9]+\.\d*)?)", + endReStr = r"\s*- Thermochemistry -", + forwardMatch = True, + repeats = False, + subMatchers = [ + SM (name = 'Frequencies', + startReStr = r"\s*Frequencies --\s+(?:(?:[-]?[0-9]+\.\d*)\s*(?:[-]?[-0-9]+\.\d*)?\s*(?:[-]?[-0-9]+\.\d*)?)", + forwardMatch = True, + repeats = True, + subFlags = SM.SubFlags.Unordered, + subMatchers = [ + SM(r"\s*Frequencies --\s+(?P([-]?[0-9]+\.\d*)\s*([-]?[-0-9]+\.\d*)?\s*([-]?[-0-9]+\.\d*)?)", repeats = True), + SM(r"\s*Red. masses --\s+(?P(.+))", repeats = True), + SM(r"\s*[0-9]+\s*[0-9]+\s*(?P([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+)\s*([-0-9.]+))", repeats = True), + SM(r"\s*[0-9]+\s*([0-9]+)?\s*([0-9]+)?"), + ]) + ] + ), + SM(name = 'Thermochemistry', + sections = ['x_gaussian_section_thermochem'], + startReStr = r"\s*Temperature", + forwardMatch = True, + subMatchers = [ + SM(r"\s*Temperature\s*(?P[0-9.]+)\s*Kelvin.\s*Pressure\s*(?P[0-9.]+)\s*Atm."), + SM(r"\s*Principal axes and moments of inertia in atomic units:"), + SM(r"\s*Eigenvalues --\s*(?P(\d+\.\d{5}))\s*?(?P(\d+\.\d{5}))\s*?(?P(\d+\.\d{5}))"), + SM(r"\s*Zero-point correction=\s*(?P[0-9.]+)"), + SM(r"\s*Thermal correction to Energy=\s*(?P[0-9.]+)"), + SM(r"\s*Thermal correction to Enthalpy=\s*(?P[0-9.]+)"), + SM(r"\s*Thermal correction to Gibbs Free Energy=\s*(?P[0-9.]+)"), + ] + ), + SM(name = 'Forceconstantmatrix', + sections = ['x_gaussian_section_force_constant_matrix'], + startReStr = r"\s*Force constants in Cartesian coordinates", + forwardMatch = True, + subMatchers = [ + SM(r"\s*Force constants in Cartesian coordinates"), + SM(r"\s*[0-9]+\s*(?P(-?\d*\.\d*D?\+?\-?\d+)|(\-?\d*\.\d*[-+DE0-9]+)\s*(\-?\d*\.\d*[-+DE0-9]+)?\s*(\-?\d*\.\d*[-+DE0-9]+)?\s*(\-?\d*\.\d*[-+DE0-9]+)?\s*(\-?\d*\.\d*[-+DE0-9]+)?)", repeats = True), + SM(r"\s*Force constants in internal coordinates") + ] + ), + SM(name = 'CompositeModelEnergies', + sections = ['x_gaussian_section_models'], + startReStr = r"\s*Temperature=\s*", + forwardMatch = False, + repeats = True, + subMatchers = [ + SM(r"\s*G1\(0 K\)=\s*[-+0-9.]+\s*G1 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G2\(0 K\)=\s*[-+0-9.]+\s*G2 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G2MP2\(0 K\)=\s*[-+0-9.]+\s*G2MP2 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G3\(0 K\)=\s*[-+0-9.]+\s*G3 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G3MP2\(0 K\)=\s*[-+0-9.]+\s*G3MP2 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G4\(0 K\)=\s*[-+0-9.]+\s*G4 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*G4MP2\(0 K\)=\s*[-+0-9.]+\s*G4MP2 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*CBS-4 \(0 K\)=\s*[-+0-9.]+\s*CBS-4 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*CBS-q \(0 K\)=\s*[-+0-9.]+\s*CBS-q Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*CBS-Q \(0 K\)=\s*[-+0-9.]+\s*CBS-Q Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*CBS-QB3 \(0 K\)=\s*[-+0-9.]+\s*CBS-QB3 Energy=\s*(?P[-+0-9.]+)"), + SM(r"\s*W1U \(0 K\)=\s*[-+0-9.]+\s*W1U Electronic Energy\s*(?P[-+0-9.]+)"), + SM(r"\s*W1RO \(0 K\)=\s*[-+0-9.]+\s*W1RO Electronic Energy\s*(?P[-+0-9.]+)"), + SM(r"\s*W1BD \(0 K\)=\s*[-+0-9.]+\s*W1BD Electronic Energy\s*(?P[-+0-9.]+)"), + ] + ), + SM(name = 'run times', + sections = ['x_gaussian_section_times'], + startReStr = r"\s*Job cpu time:", + forwardMatch = True, + subMatchers = [ + SM(r"\s*Job cpu time:\s*(?P\s*[0-9]+\s*[a-z]+\s*[0-9]+\s*[a-z]+\s*[0-9]+\s*[a-z]+\s*[0-9.]+\s*[a-z]+)"), + SM(r"\s*Normal termination of Gaussian\s*[0-9]+\s* at \s*(?P[A-Za-z]+\s*[A-Za-z]+\s*[0-9]+\s*[0-9:]+\s*[0-9]+)"), + ] + ) + ]) + ]) + ]) + ]) + +import nomad_meta_info +metaInfoPath = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(nomad_meta_info.__file__)), "gaussian.nomadmetainfo.json")) +metaInfoEnv, warnings = loadJsonFile(filePath = metaInfoPath, dependencyLoader = None, extraArgsHandling = InfoKindEl.ADD_EXTRA_ARGS, uri = None) + +parserInfo = { + "name": "parser_gaussian", + "version": "1.0" +} + +class GaussianParserContext(object): + """Context for parsing Gaussian output file. + + This class keeps tracks of several Gaussian settings to adjust the parsing to them. + The onClose_ functions allow processing and writing of cached values after a section is closed. + They take the following arguments: + backend: Class that takes care of writing and caching of metadata. + gIndex: Index of the section that is closed. + section: The cached values and sections that were found in the section that is closed. + """ + def __init__(self): + # dictionary of energy values, which are tracked between SCF iterations and written after convergence + self.totalEnergyList = { + 'x_gaussian_hf_detect': None, + 'x_gaussian_energy_scf': None, + 'x_gaussian_perturbation_energy': None, + 'x_gaussian_electronic_kinetic_energy': None, + 'x_gaussian_energy_electrostatic': None, + 'x_gaussian_energy_error': None, + } + + def initialize_values(self): + """Initializes the values of certain variables. + + This allows a consistent setting and resetting of the variables, + when the parsing starts and when a section_run closes. + """ + self.secMethodIndex = None + self.secSystemDescriptionIndex = 0 + # start with -1 since zeroth iteration is the initialization + self.scfIterNr = -1 + self.singleConfCalcs = [] + self.scfConvergence = False + self.geoConvergence = False + self.scfenergyconverged = 0.0 + self.scfkineticenergyconverged = 0.0 + self.scfelectrostaticenergy = 0.0 + self.periodicCalc = False + + def startedParsing(self, path, parser): + self.parser = parser + # save metadata + self.metaInfoEnv = self.parser.parserBuilder.metaInfoEnv + # allows to reset values if the same superContext is used to parse different files + self.initialize_values() + + def onClose_section_run(self, backend, gIndex, section): + """Trigger called when section_run is closed. + + Write convergence of geometry optimization. + Variables are reset to ensure clean start for new run. + """ + global sampling_method + sampling_method = "" + # write geometry optimization convergence + gIndexTmp = backend.openSection('section_frame_sequence') + backend.addValue('geometry_optimization_converged', self.geoConvergence) + backend.closeSection('section_frame_sequence', gIndexTmp) + # frame sequence + if self.geoConvergence: + sampling_method = "geometry_optimization" + elif len(self.singleConfCalcs) > 1: + pass # to do + else: + return + samplingGIndex = backend.openSection("section_sampling_method") + backend.addValue("sampling_method", sampling_method) + backend.closeSection("section_sampling_method", samplingGIndex) + frameSequenceGIndex = backend.openSection("section_frame_sequence") + backend.addValue("frame_sequence_to_sampling_ref", samplingGIndex) + backend.addArrayValues("frame_sequence_local_frames_ref", np.asarray(self.singleConfCalcs)) + backend.closeSection("section_frame_sequence", frameSequenceGIndex) + # reset all variables + self.initialize_values() + + def onClose_x_gaussian_section_geometry(self, backend, gIndex, section): + xCoord = section["x_gaussian_atom_x_coord"] + yCoord = section["x_gaussian_atom_y_coord"] + zCoord = section["x_gaussian_atom_z_coord"] + numbers = section["x_gaussian_atomic_number"] + atom_coords = np.zeros((len(xCoord),3), dtype=float) + atom_numbers = np.zeros(len(xCoord), dtype=int) + atomic_symbols = np.empty((len(xCoord)), dtype=object) + for i in range(len(xCoord)): + atom_coords[i,0] = xCoord[i] + atom_coords[i,1] = yCoord[i] + atom_coords[i,2] = zCoord[i] + for i in range(len(xCoord)): + atom_numbers[i] = numbers[i] + atomic_symbols[i] = ase.data.chemical_symbols[atom_numbers[i]] + + if self.secSystemDescriptionIndex > 0: + self.secSystemDescriptionIndex = backend.openSection("section_system") + + backend.addArrayValues("atom_labels", atomic_symbols, self.secSystemDescriptionIndex) + backend.addArrayValues("atom_positions", atom_coords, self.secSystemDescriptionIndex) + backend.addValue("x_gaussian_number_of_atoms",len(atomic_symbols), self.secSystemDescriptionIndex) + + if self.secSystemDescriptionIndex > 0: + backend.closeSection("section_system", self.secSystemDescriptionIndex) + else: + self.secSystemDescriptionIndex = 1 + + def onClose_x_gaussian_section_atom_forces(self, backend, gIndex, section): + xForce = section["x_gaussian_atom_x_force"] + yForce = section["x_gaussian_atom_y_force"] + zForce = section["x_gaussian_atom_z_force"] + atom_forces = np.zeros((len(xForce),3), dtype=float) + for i in range(len(xForce)): + atom_forces[i,0] = xForce[i] + atom_forces[i,1] = yForce[i] + atom_forces[i,2] = zForce[i] + backend.addArrayValues("atom_forces_raw", atom_forces) + + def onOpen_section_single_configuration_calculation(self, backend, gIndex, section): + self.singleConfCalcs.append(gIndex) + + def onClose_section_single_configuration_calculation(self, backend, gIndex, section): + """Trigger called when section_single_configuration_calculation is closed. + Write number of SCF iterations and convergence. + Check for convergence of geometry optimization. + """ + # write SCF convergence and reset + backend.addValue('single_configuration_calculation_converged', self.scfConvergence) + self.scfConvergence = False + # start with -1 since zeroth iteration is the initialization + self.scfIterNr = -1 + # write the references to section_method and section_system + backend.addValue('single_configuration_to_calculation_method_ref', self.secMethodIndex) + backend.addValue('single_configuration_calculation_to_system_ref', self.secSystemDescriptionIndex) + + def onClose_x_gaussian_section_geometry_optimization_info(self, backend, gIndex, section): + # check for geometry optimization convergence + if section['x_gaussian_geometry_optimization_converged'] is not None: + if section['x_gaussian_geometry_optimization_converged'] == ['Optimization completed']: + self.geoConvergence = True + elif section['x_gaussian_geometry_optimization_converged'] == ['Optimization stopped']: + self.geoConvergence = False + + def onClose_section_scf_iteration(self, backend, gIndex, section): + # count number of SCF iterations + self.scfIterNr += 1 + # check for SCF convergence + if section['x_gaussian_single_configuration_calculation_converged'] is not None: + self.scfConvergence = True + if section['x_gaussian_energy_scf']: + self.scfenergyconverged = float(str(section['x_gaussian_energy_scf']).replace("[","").replace("]","").replace("D","E")) + self.scfcharacter = section['x_gaussian_hf_detect'] + if (self.scfcharacter != ['RHF'] and self.scfcharacter != ['ROHF'] and self.scfcharacter != ['UHF']): + self.energytotal = self.scfenergyconverged + backend.addValue('energy_total', self.energytotal) + else: + pass + if section['x_gaussian_electronic_kinetic_energy']: + self.scfkineticenergyconverged = float(str(section['x_gaussian_electronic_kinetic_energy']).replace("[","").replace("]","").replace("D","E")) + self.scfelectrostaticenergy = self.scfenergyconverged - self.scfkineticenergyconverged + backend.addValue('x_gaussian_energy_electrostatic', self.scfelectrostaticenergy) + + def onClose_section_eigenvalues(self, backend, gIndex, section): + eigenenergies = str(section["x_gaussian_alpha_occ_eigenvalues_values"]) + eigenen1 = [] + if('*' in eigenenergies): + energy = [0.0] + else: + energy = [float(f) for f in eigenenergies[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace(" ."," 0.").replace(" -."," -0.").replace("\\n","").replace("-"," -").split()] + eigenen1 = np.append(eigenen1, energy) + if(section["x_gaussian_beta_occ_eigenvalues_values"]): + occoccupationsalp = np.ones(len(eigenen1), dtype=float) + else: + occoccupationsalp = 2.0 * np.ones(len(eigenen1), dtype=float) + + eigenenergies = str(section["x_gaussian_alpha_vir_eigenvalues_values"]) + eigenen2 = [] + if('*' in eigenenergies): + energy = [0.0] + else: + energy = [float(f) for f in eigenenergies[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace(" ."," 0.").replace(" -."," -0.").replace("\\n","").replace("-"," -").split()] + eigenen2 = np.append(eigenen2, energy) + viroccupationsalp = np.zeros(len(eigenen2), dtype=float) + leneigenenconalp = len(eigenen1) + len(eigenen2) + eigenenconalp = np.concatenate((eigenen1,eigenen2), axis=0) + eigenenconalp = convert_unit(eigenenconalp, "hartree", "J") + occupconalp = np.concatenate((occoccupationsalp, viroccupationsalp), axis=0) + eigenenconalpnew = np.reshape(eigenenconalp,(1, 1, len(eigenenconalp))) + occupconalpnew = np.reshape(occupconalp,(1, 1, len(occupconalp))) + if(section["x_gaussian_beta_occ_eigenvalues_values"]): + pass + else: + backend.addArrayValues("eigenvalues_values", eigenenconalpnew) + backend.addArrayValues("eigenvalues_occupation", occupconalpnew) + + if(section["x_gaussian_beta_occ_eigenvalues_values"]): + eigenenergies = str(section["x_gaussian_beta_occ_eigenvalues_values"]) + eigenen1 = [] + if('*' in eigenenergies): + energy = [0.0] + else: + energy = [float(f) for f in eigenenergies[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace(" ."," 0.").replace(" -."," -0.").replace("\\n","").replace("-"," -").split()] + eigenen1 = np.append(eigenen1, energy) + occoccupationsbet = np.ones(len(eigenen1), dtype=float) + eigenenergies = str(section["x_gaussian_beta_vir_eigenvalues_values"]) + eigenen2 = [] + if('*' in eigenenergies): + energy = [0.0] + else: + energy = [float(f) for f in eigenenergies[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace(" ."," 0.").replace(" -."," -0.").replace("\\n","").replace("-"," -").split()] + eigenen2 = np.append(eigenen2, energy) + viroccupationsbet = np.zeros(len(eigenen2), dtype=float) + leneigenenconbet = len(eigenen1) + len(eigenen2) + eigenenconbet = np.concatenate((eigenen1,eigenen2), axis=0) + eigenenconbet = convert_unit(eigenenconbet, "hartree", "J") + occupconbet = np.concatenate((occoccupationsbet, viroccupationsbet), axis=0) + if(leneigenenconalp >= leneigenenconbet): + eigenenall = np.zeros(2*leneigenenconalp) + occupall = np.zeros(2*leneigenenconalp) + else: + eigenenall = np.zeros(2*leneigenenconbet) + occupall = np.zeros(2*leneigenenconbet) + eigenenall[:len(eigenenconalp) + len(eigenenconbet)] = np.concatenate((eigenenconalp,eigenenconbet), axis=0) + occupall[:len(occupconalp) + len(occupconbet)] = np.concatenate((occupconalp,occupconbet), axis=0) + eigenenall = np.reshape(eigenenall,(2, 1, max(len(eigenenconalp),len(eigenenconbet)))) + occupall = np.reshape(occupall,(2, 1, max(len(occupconalp),len(occupconbet)))) + backend.addArrayValues("eigenvalues_values", eigenenall) + backend.addArrayValues("eigenvalues_occupation", occupall) + + def onClose_x_gaussian_section_orbital_symmetries(self, backend, gIndex, section): + symoccalpha = str(section["x_gaussian_alpha_occ_symmetry_values"]) + symviralpha = str(section["x_gaussian_alpha_vir_symmetry_values"]) + if(section["x_gaussian_beta_occ_symmetry_values"]): + symoccbeta = str(section["x_gaussian_beta_occ_symmetry_values"]) + symvirbeta = str(section["x_gaussian_beta_vir_symmetry_values"]) + + symmetry = [str(f) for f in symoccalpha[1:].replace(",","").replace("(","").replace(")","").replace("]","").replace("'A","A").replace("\\'","'").replace("A''","A'").replace("'E","E").replace("G'","G").replace("\"A'\"","A'").split()] + sym1 = [] + sym1 = np.append(sym1, symmetry) + symmetry = [str(f) for f in symviralpha[1:].replace(",","").replace("(","").replace(")","").replace("]","").replace("'A","A").replace("\\'","'").replace("A''","A'").replace("\"A'\"","A'").replace("'E","E").replace("G'","G").split()] + sym2 = [] + sym2 = np.append(sym2, symmetry) + symmetrycon = np.concatenate((sym1, sym2), axis=0) + backend.addArrayValues("x_gaussian_alpha_symmetries", symmetrycon) + + if(section["x_gaussian_beta_occ_symmetry_values"]): + symmetry = [str(f) for f in symoccbeta[1:].replace(",","").replace("(","").replace(")","").replace("]","").replace("'A","A").replace("\\'","'").replace("A''","A'").replace("\"A'\"","A'").replace("'E","E").replace("G'","G").split()] + sym1 = [] + sym1 = np.append(sym1, symmetry) + symmetry = [str(f) for f in symvirbeta[1:].replace(",","").replace("(","").replace(")","").replace("]","").replace("'A","A").replace("\\'","'").replace("A''","A'").replace("\"A'\"","A'").replace("'E","E").replace("G'","G").split()] + sym2 = [] + sym2 = np.append(sym2, symmetry) + symmetrycon = np.concatenate((sym1, sym2), axis=0) + backend.addArrayValues("x_gaussian_beta_symmetries", symmetrycon) + + def onClose_x_gaussian_section_molecular_multipoles(self, backend, gIndex, section): + if(section["quadrupole_moment_xx"]): + x_gaussian_number_of_lm_molecular_multipoles = 35 + else: + x_gaussian_number_of_lm_molecular_multipoles = 4 + + x_gaussian_molecular_multipole_m_kind = 'polynomial' + + char = str(section["charge"]) + cha = str([char]) + charge = [float(f) for f in cha[1:].replace("-."," -0.").replace("'."," 0.").replace("'","").replace("[","").replace("]","").replace(",","").replace('"','').split()] + + if(section["dipole_moment_x"]): + dipx = section["dipole_moment_x"] + dipy = section["dipole_moment_y"] + dipz = section["dipole_moment_z"] + dip = str([dipx, dipy, dipz]) + dipoles = [float(f) for f in dip[1:].replace("-."," -0.").replace("'."," 0.").replace("'","").replace("[","").replace("]","").replace(",","").split()] + dipoles = convert_unit(dipoles, "debye", "coulomb * meter") + + if(section["quadrupole_moment_xx"]): + quadxx = section["quadrupole_moment_xx"] + quadxy = section["quadrupole_moment_xy"] + quadyy = section["quadrupole_moment_yy"] + quadxz = section["quadrupole_moment_xz"] + quadyz = section["quadrupole_moment_yz"] + quadzz = section["quadrupole_moment_zz"] + quad = str([quadxx, quadxy, quadyy, quadxz, quadyz, quadzz]) + quadrupoles = [float(f) for f in quad[1:].replace("-."," -0.").replace("'."," 0.").replace("'","").replace("[","").replace("]","").replace(",","").split()] + quadrupoles = convert_unit(quadrupoles, "debye * angstrom", "coulomb * meter**2") + + if(section["octapole_moment_xxx"]): + octaxxx = section["octapole_moment_xxx"] + octayyy = section["octapole_moment_yyy"] + octazzz = section["octapole_moment_zzz"] + octaxyy = section["octapole_moment_xyy"] + octaxxy = section["octapole_moment_xxy"] + octaxxz = section["octapole_moment_xxz"] + octaxzz = section["octapole_moment_xzz"] + octayzz = section["octapole_moment_yzz"] + octayyz = section["octapole_moment_yyz"] + octaxyz = section["octapole_moment_xyz"] + octa = str([octaxxx, octayyy, octazzz, octaxyy, octaxxy, octaxxz, octaxzz, octayzz, octayyz, octaxyz]) + octapoles = [float(f) for f in octa[1:].replace("-."," -0.").replace("'."," 0.").replace("'","").replace("[","").replace("]","").replace(",","").split()] + octapoles = convert_unit(octapoles, "debye * angstrom**2", "coulomb * meter**3") + + if(section["hexadecapole_moment_xxxx"]): + hexadecaxxxx = section["hexadecapole_moment_xxxx"] + hexadecayyyy = section["hexadecapole_moment_yyyy"] + hexadecazzzz = section["hexadecapole_moment_zzzz"] + hexadecaxxxy = section["hexadecapole_moment_xxxy"] + hexadecaxxxz = section["hexadecapole_moment_xxxz"] + hexadecayyyx = section["hexadecapole_moment_yyyx"] + hexadecayyyz = section["hexadecapole_moment_yyyz"] + hexadecazzzx = section["hexadecapole_moment_zzzx"] + hexadecazzzy = section["hexadecapole_moment_zzzy"] + hexadecaxxyy = section["hexadecapole_moment_xxyy"] + hexadecaxxzz = section["hexadecapole_moment_xxzz"] + hexadecayyzz = section["hexadecapole_moment_yyzz"] + hexadecaxxyz = section["hexadecapole_moment_xxyz"] + hexadecayyxz = section["hexadecapole_moment_yyxz"] + hexadecazzxy = section["hexadecapole_moment_zzxy"] + hexa = str([hexadecaxxxx, hexadecayyyy, hexadecazzzz, hexadecaxxxy, hexadecaxxxz, hexadecayyyx, hexadecayyyz, + hexadecazzzx, hexadecazzzy, hexadecaxxyy, hexadecaxxzz, hexadecayyzz, hexadecaxxyz, hexadecayyxz, hexadecazzxy]) + hexadecapoles = [float(f) for f in hexa[1:].replace("-."," -0.").replace("'."," 0.").replace("'","").replace("[","").replace("]","").replace(",","").split()] + hexadecapoles = convert_unit(hexadecapoles, "debye * angstrom**3", "coulomb * meter**4") + + if(section["quadrupole_moment_xx"]): + multipoles = np.hstack((charge, dipoles, quadrupoles, octapoles, hexadecapoles)) + else: + multipoles = np.hstack((charge, dipoles)) + + x_gaussian_molecular_multipole_values = np.resize(multipoles, (x_gaussian_number_of_lm_molecular_multipoles)) + + backend.addArrayValues("x_gaussian_molecular_multipole_values", x_gaussian_molecular_multipole_values) + backend.addValue("x_gaussian_molecular_multipole_m_kind", x_gaussian_molecular_multipole_m_kind) + + def onClose_x_gaussian_section_frequencies(self, backend, gIndex, section): + frequencies = str(section["x_gaussian_frequency_values"]) + vibfreqs = [] + freqs = [float(f) for f in frequencies[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace("\\n","").replace(" ."," 0.").replace(" -."," -0.").split()] + vibfreqs = np.append(vibfreqs, freqs) + vibfreqs = convert_unit(vibfreqs, "inversecm", "J") + backend.addArrayValues("x_gaussian_frequencies", vibfreqs) + + masses = str(section["x_gaussian_reduced_masses"]) + vibreducedmasses = [] + reduced = [float(f) for f in masses[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace(" ."," 0.").split()] + vibreducedmasses = np.append(vibreducedmasses, reduced) + vibreducedmasses = convert_unit(vibreducedmasses, "amu", "kilogram") + backend.addArrayValues("x_gaussian_red_masses", vibreducedmasses) + + vibnormalmodes = [] + vibdisps = str(section["x_gaussian_normal_modes"]) + disps = [float(s) for s in vibdisps[1:].replace("'","").replace(",","").replace("]","").replace("one","").replace("\\n","").replace(" ."," 0.").replace(" -."," -0.").split()] + dispsnew = np.zeros(len(disps), dtype = float) + +# Reorder disps + + if len(vibfreqs) % 3 == 0: + k = 0 + for p in range(0,len(vibfreqs) // 3): + M = int(len(disps)/len(vibfreqs)) * (p+1) + for m in range(3): + for n in range(M - int(len(disps) / len(vibfreqs)),M,3): + for l in range(3): + dispsnew[k] = disps[3*(n + m) + l] + k = k + 1 + elif len(vibfreqs) % 3 != 0: + k = 0 + for p in range(len(vibfreqs)-1,0,-3): + M = (len(disps) - int(len(disps) / len(vibfreqs))) // p + for m in range(3): + for n in range(M - int(len(disps) / len(vibfreqs)),M,3): + for l in range(3): + dispsnew[k] = disps[3*(n + m) + l] + k = k + 1 + for m in range(int(len(disps) / len(vibfreqs))): + dispsnew[k] = disps[k] + k = k + 1 + + vibnormalmodes = np.append(vibnormalmodes, dispsnew) + if len(vibfreqs) != 0: + natoms = int(len(disps) / len(vibfreqs) / 3) + vibnormalmodes = np.reshape(vibnormalmodes,(len(vibfreqs),natoms,3)) + backend.addArrayValues("x_gaussian_normal_mode_values", vibnormalmodes) + + def onClose_x_gaussian_section_force_constant_matrix(self, backend, gIndex, section): + + forcecnstvalues = [] + forceconst = str(section["x_gaussian_force_constants"]) + numbers = [float(s) for s in forceconst[1:].replace("'","").replace(",","").replace("]","").replace("\\n","").replace("D","E").replace(" ."," 0.").replace(" -."," -0.").split()] + length = len(numbers) + dim = int(((1 + 8 * length)**0.5 - 1) / 2) + cartforceconst = np.zeros([dim, dim]) + forcecnstvalues = np.append(forcecnstvalues, numbers) + if dim > 6: + l = 0 + for i in range(0,5): + for k in range(0,i+1): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(5,dim): + for k in range(0,5): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(5,dim-2): + for k in range(5,i+1): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(dim-2,dim): + for k in range(5,dim-2): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(dim-2,dim): + for k in range(i,dim): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + elif dim == 6: + l = 0 + for i in range(0,5): + for k in range(0,i+1): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(5,dim): + for k in range(0,5): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + for i in range(dim,dim): + for k in range(i,dim): + l = l + 1 + cartforceconst[i,k] = forcecnstvalues[l-1] + + for i in range(0,dim): + for k in range(i+1,dim): + cartforceconst[i,k] = cartforceconst[k,i] + + cartforceconst = convert_unit(cartforceconst, "forceAu / bohr", "J / (meter**2)") + + backend.addArrayValues("x_gaussian_force_constant_values", cartforceconst) + + def onOpen_section_method(self, backend, gIndex, section): + # keep track of the latest method section + self.secMethodIndex = gIndex + + def onClose_section_method(self, backend, gIndex, section): + # handling of xc functional + # Dictionary for conversion of xc functional name in Gaussian to metadata format. + # The individual x and c components of the functional are given as dictionaries. + # Possible key of such a dictionary is 'name'. + xcDict = { + 'S': [{'name': 'LDA_X'}], + 'XA': [{'name': 'X_ALPHA'}], + 'VWN': [{'name': 'LDA_C_VWN'}], + 'VWN3': [{'name': 'LDA_C_VWN_3'}], + 'LSDA': [{'name': 'LDA_X'}, {'name': 'LDA_C_VWN'}], + 'B': [{'name': 'GGA_X_B88'}], + 'BLYP': [{'name': 'GGA_C_LYP'}, {'name': 'GGA_X_B88'}], + 'PBEPBE': [{'name': 'GGA_C_PBE'}, {'name': 'GGA_X_PBE'}], + 'PBEH': [{'name': 'GGA_X_PBEH'}], + 'WPBEH': [{'name': 'GGA_X_WPBEH'}], + 'PW91PW91': [{'name': 'GGA_C_PW91'}, {'name': 'GGA_X_PW91'}], + 'M06L': [{'name': 'MGGA_C_M06_L'}, {'name': 'MGGA_X_M06_L'}], + 'M11L': [{'name': 'MGGA_C_M11_L'}, {'name': 'MGGA_X_M11_L'}], + 'SOGGA11': [{'name': 'GGA_XC_SOGGA11'}], + 'MN12L': [{'name': 'GGA_XC_MN12L'}], + 'N12': [{'name': 'GGA_C_N12'}, {'name': 'GGA_X_N12'}], + 'VSXC': [{'name': 'MGGA_XC_VSXC'}], + 'HCTH93': [{'name': 'GGA_XC_HCTH_93'}], + 'HCTH147': [{'name': 'GGA_XC_HCTH_147'}], + 'HCTH407': [{'name': 'GGA_XC_HCTH_407'}], + 'HCTH': [{'name': 'GGA_XC_HCTH_407'}], + 'B97D': [{'name': 'GGA_XC_B97D'}], + 'B97D3': [{'name': 'GGA_XC_B97D3'}], + 'MPW': [{'name': 'GGA_X_MPW'}], + 'G96': [{'name': 'GGA_X_G96'}], + 'O': [{'name': 'GGA_X_O'}], + 'BRX': [{'name': 'GGA_X_BRX'}], + 'PKZB': [{'name': 'GGA_C_PKZB'}, {'name': 'GGA_X_PKZB'}], + 'PL': [{'name': 'C_PL'}], + 'P86': [{'name': 'GGA_C_P86'}], + 'B95': [{'name': 'MGGA_C_B95'}], + 'KCIS': [{'name': 'GGA_C_KCIS'}], + 'BRC': [{'name': 'GGA_C_BRC'}], + 'VP86': [{'name': 'GGA_C_VP86'}], + 'V5LYP': [{'name': 'GGA_C_V5LYP'}], + 'THCTH': [{'name': 'MGGA_XC_TAU_HCTH'}], + 'TPSSTPSS': [{'name': 'MGGA_C_TPSS'}, {'name': 'MGGA_X_TPSS'}], + 'B3LYP': [{'name': 'HYB_GGA_XC_B3LYP'}], + 'B3PW91': [{'name': 'HYB_GGA_XC_B3PW91'}], + 'B3P86': [{'name': 'HYB_GGA_XC_B3P86'}], + 'B1B95': [{'name': 'HYB_GGA_XC_B1B95'}], + 'MPW1PW91': [{'name': 'HYB_GGA_XC_MPW1PW91'}], + 'MPW1LYP': [{'name': 'HYB_GGA_XC_MPW1LYP'}], + 'MPW1PBE': [{'name': 'HYB_GGA_XC_MPW1PBE'}], + 'MPW3PBE': [{'name': 'HYB_GGA_XC_MPW3PBE'}], + 'B98': [{'name': 'HYB_GGA_XC_B98'}], + 'B971': [{'name': 'HYB_GGA_XC_B971'}], + 'B972': [{'name': 'HYB_GGA_XC_B972'}], + 'O3LYP': [{'name': 'HYB_GGA_XC_O3LYP'}], + 'TPSSH': [{'name': 'HYB_GGA_XC_TPSSh'}], + 'BMK': [{'name': 'HYB_MGGA_XC_BMK'}], + 'X3LYP': [{'name': 'HYB_GGA_XC_X3LYP'}], + 'THCTHHYB': [{'name': 'HYB_MGGA_XC_THCTHHYB'}], + 'BHANDH': [{'name': 'HYB_GGA_XC_BHANDH'}], + 'BHANDHLYP': [{'name': 'HYB_GGA_XC_BHANDHLYP'}], + 'APF': [{'name': 'HYB_GGA_XC_APF'}], + 'APFD': [{'name': 'HYB_GGA_XC_APFD'}], + 'B97D': [{'name': 'HYB_GGA_XC_B97D'}], + 'RHF': [{'name': 'RHF_X'}], + 'UHF': [{'name': 'UHF_X'}], + 'ROHF': [{'name': 'ROHF_X'}], + 'OHSE2PBE': [{'name': 'HYB_GGA_XC_HSE03'}], + 'HSEH1PBE': [{'name': 'HYB_GGA_XC_HSE06'}], + 'OHSE1PBE': [{'name': 'HYB_GGA_XC_HSEOLD'}], + 'PBEH1PBE': [{'name': 'HYB_GGA_XC_PBEH1PBE'}], + 'PBE1PBE': [{'name': 'HYB_GGA_XC_PBE1PBE'}], + 'M05': [{'name': 'HYB_MGGA_XC_M05'}], + 'M052X': [{'name': 'HYB_MGGA_XC_M05_2X'}], + 'M06': [{'name': 'HYB_MGGA_XC_M06'}], + 'M062X': [{'name': 'HYB_MGGA_XC_M06_2X'}], + 'M06HF': [{'name': 'HYB_MGGA_XC_M06_HF'}], + 'M11': [{'name': 'HYB_MGGA_XC_M11'}], + 'SOGGAX11': [{'name': 'HYB_MGGA_XC_SOGGA11_X'}], + 'MN12SX': [{'name': 'HYB_MGGA_XC_MN12_SX'}], + 'N12SX': [{'name': 'HYB_MGGA_XC_N12_SX'}], + 'LC-WPBE': [{'name': 'LC-WPBE'}], + 'CAM-B3LYP': [{'name': 'CAM-B3LYP'}], + 'WB97': [{'name': 'WB97'}], + 'WB97X': [{'name': 'WB97X'}], + 'WB97XD': [{'name': 'WB97XD'}], + 'HISSBPBE': [{'name': 'HISSBPBE'}], + 'B2PLYP': [{'name': 'B2PLYP'}], + 'MPW2PLYP': [{'name': 'MPW2PLYP'}], + 'B2PLYPD': [{'name': 'B2PLYPD'}], + 'MPW2PLYPD': [{'name': 'MPW2PLYPD'}], + 'B97D3': [{'name': 'B97D3'}], + 'B2PLYPD3': [{'name': 'B2PLYPD3'}], + 'MPW2PLYPD3': [{'name': 'MPW2PLYPD3'}], + 'LC-': [{'name': 'LONG-RANGE CORRECTED'}], + } + + methodDict = { + 'AMBER': [{'name': 'Amber'}], + 'DREIDING': [{'name': 'Dreiding'}], + 'UFF': [{'name': 'UFF'}], + 'AM1': [{'name': 'AM1'}], + 'PM3': [{'name': 'PM3'}], + 'PM3MM': [{'name': 'PM3MM'}], + 'PM3D3': [{'name': 'PM3D3'}], + 'PM6': [{'name': 'PM6'}], + 'PDDG': [{'name': 'PDDG'}], + 'CNDO': [{'name': 'CNDO'}], + 'INDO': [{'name': 'INDO'}], + 'MINDO': [{'name': 'MINDO'}], + 'MINDO3': [{'name': 'MINDO3'}], + 'ZINDO': [{'name': 'ZINDO'}], + 'HUCKEL': [{'name': 'HUCKEL'}], + 'EXTENDEDHUCKEL': [{'name': 'HUCKEL'}], + 'ONIOM': [{'name': 'ONIOM'}], + 'HF': [{'name': 'HF'}], + 'RHF': [{'name': 'RHF'}], + 'UHF': [{'name': 'UHF'}], + 'ROHF': [{'name': 'ROHF'}], + 'GVB': [{'name': 'GVB'}], + 'DFT': [{'name': 'DFT'}], + 'CID': [{'name': 'CID'}], + 'CISD': [{'name': 'CISD'}], + 'CIS': [{'name': 'CIS'}], + 'BD': [{'name': 'BD'}], + 'BD(T)': [{'name': 'BD(T)'}], + 'CCD': [{'name': 'CCD'}], + 'CCSD': [{'name': 'CCSD'}], + 'EOMCCSD': [{'name': 'EOMCCSD'}], + 'QCISD': [{'name': 'QCISD'}], + 'CCSD(T)': [{'name': 'CCSD(T)'}], + 'QCISD(T)': [{'name': 'QCISD(T)'}], + 'QCISD(TQ)': [{'name': 'QCISD(TQ)'}], + 'MP2': [{'name': 'MP2'}], + 'MP3': [{'name': 'MP3'}], + 'MP4': [{'name': 'MP4'}], + 'MP4DQ': [{'name': 'MP4DQ'}], + 'MP4(DQ)': [{'name': 'MP4DQ'}], + 'MP4SDQ': [{'name': 'MP4SDQ'}], + 'MP4(SDQ)': [{'name': 'MP4SDQ'}], + 'MP4SDTQ': [{'name': 'MP4SDTQ'}], + 'MP4(SDTQ)': [{'name': 'MP4SDTQ'}], + 'MP5': [{'name': 'MP5'}], + 'CAS': [{'name': 'CASSCF'}], + 'CASSCF': [{'name': 'CASSCF'}], + 'G1': [{'name': 'G1'}], + 'G2': [{'name': 'G2'}], + 'G2MP2': [{'name': 'G2MP2'}], + 'G3': [{'name': 'G3'}], + 'G3MP2': [{'name': 'G3MP2'}], + 'G3B3': [{'name': 'G3B3'}], + 'G3MP2B3': [{'name': 'G3MP2B3'}], + 'G4': [{'name': 'G4'}], + 'G4MP2': [{'name': 'G4MP2'}], + 'CBSEXTRAP': [{'name': 'CBSExtrapolate'}], + 'CBSEXTRAPOLATE': [{'name': 'CBSExtrapolate'}], + 'CBS-4M': [{'name': 'CBS-4M'}], + 'CBS-4O': [{'name': 'CBS-4O'}], + 'CBS-QB3': [{'name': 'CBS-QB3'}], + 'CBS-QB3O': [{'name': 'CBS-QB3O'}], + 'CBS-APNO': [{'name': 'CBS-APNO'}], + 'W1U': [{'name': 'W1U'}], + 'W1BD': [{'name': 'W1BD'}], + 'W1RO': [{'name': 'W1RO'}], + } + + basissetDict = { + 'STO-3G': [{'name': 'STO-3G'}], + '3-21G': [{'name': '3-21G'}], + '6-21G': [{'name': '6-21G'}], + '4-31G': [{'name': '4-31G'}], + '6-31G': [{'name': '6-31G'}], + '6-311G': [{'name': '6-311G'}], + 'D95V': [{'name': 'D95V'}], + 'D95': [{'name': 'D95'}], + 'CC-PVDZ': [{'name': 'cc-pVDZ'}], + 'CC-PVTZ': [{'name': 'cc-pVTZ'}], + 'CC-PVQZ': [{'name': 'cc-pVQZ'}], + 'CC-PV5Z': [{'name': 'cc-pV5Z'}], + 'CC-PV6Z': [{'name': 'cc-pV6Z'}], + 'SV': [{'name': 'SV'}], + 'SVP': [{'name': 'SVP'}], + 'TZV': [{'name': 'TZV'}], + 'TZVP': [{'name': 'TZVP'}], + 'DEF2SV': [{'name': 'Def2SV'}], + 'DEF2SVP': [{'name': 'Def2SVP'}], + 'DEF2SVPP': [{'name': 'Def2SVPP'}], + 'DEF2TZV': [{'name': 'Def2TZV'}], + 'DEF2TZVP': [{'name': 'Def2TZVP'}], + 'DEF2TZVPP': [{'name': 'Def2TZVPP'}], + 'DEF2QZV': [{'name': 'Def2QZV'}], + 'DEF2QZVP': [{'name': 'Def2QZVP'}], + 'DEF2QZVPP': [{'name': 'Def2QZVPP'}], + 'QZVP': [{'name': 'QZVP'}], + 'MIDIX': [{'name': 'MidiX'}], + 'EPR-II': [{'name': 'EPR-II'}], + 'EPR-III': [{'name': 'EPR-III'}], + 'UGBS': [{'name': 'UGBS'}], + 'MTSMALL': [{'name': 'MTSmall'}], + 'DGDZVP': [{'name': 'DGDZVP'}], + 'DGDZVP2': [{'name': 'DGDZVP2'}], + 'DGTZVP': [{'name': 'DGTZVP'}], + 'CBSB3': [{'name': 'CBSB3'}], + 'CBSB7': [{'name': 'CBSB7'}], + 'SHC': [{'name': 'SHC'}], + 'SEC': [{'name': 'SHC'}], + 'CEP-4G': [{'name': 'CEP-4G'}], + 'CEP-31G': [{'name': 'CEP-31G'}], + 'CEP-121G': [{'name': 'CEP-121G'}], + 'LANL1': [{'name': 'LANL1'}], + 'LANL2': [{'name': 'LANL2'}], + 'SDD': [{'name': 'SDD'}], + 'OLDSDD': [{'name': 'OldSDD'}], + 'SDDALL': [{'name': 'SDDAll'}], + 'GEN': [{'name': 'General'}], + 'GENECP': [{'name': 'General ECP'}], + 'CHKBAS': [{'name': 'CHKBAS'}], + 'EXTRABASIS': [{'name': 'ExtraBasis'}], + 'DGA1': [{'name': 'DGA1'}], + 'DGA2': [{'name': 'DGA2'}], + 'SVPFIT': [{'name': 'SVPFit'}], + 'TZVPFIT': [{'name': 'TZVPFit'}], + 'W06': [{'name': 'W06'}], + 'CHF': [{'name': 'CHF'}], + 'FIT': [{'name': 'FIT'}], + 'AUTO': [{'name': 'AUTO'}], + } + + global xc, method, basisset, xcWrite, methodWrite, basissetWrite, methodreal, basissetreal, exc, corr, exccorr, methodprefix + xc = None + method = None + basisset = None + xcWrite = False + methodWrite = False + basissetWrite = False + methodreal = None + basissetreal = None + methodprefix = None + exc = None + corr = None + exccorr = None + + settings = section["x_gaussian_settings"] + settings1 = str(settings[0]).strip() + settings2 = str(settings[1]).strip() + settings = [settings1, settings2] + settings = [''.join(map(str,settings))] + settings = str(settings) + settings = re.sub('[-]{2,}', '', settings) + backend.addValue("x_gaussian_settings_corrected", settings) + + method1 = settings.replace("['#p ","").replace("['#P ","").replace("['#","") + method1 = method1.upper() + + if 'ONIOM' not in method1: + if settings.find("/") >= 0: + method1 = settings.split('/')[0].replace("['#p ","").replace("['#P ","").replace("['#","") + method1 = method1.upper() + for x in method1.split(): + method2 = str(x) + if method2 != 'RHF' and method2 != 'UHF' and method2 != 'ROHF' and method2 != 'UFF': + if (method2[0] == 'R' and method2[0:2] != 'RO') or method2[0] == 'U': + methodprefix = method2[0] + method2 = method2[1:] + elif method2[0:2] == 'RO': + methodprefix = method2[0:2] + method2 = method2[2:] + if method2[0:2] == 'SV' or method2[0] == 'B' or method2[0] == 'O': + if method2[1] != '2' and method2[1] != '3': + if method2[0] in xcDict.keys() and method2[1:] in xcDict.keys(): + exc = method2[0] + corr = method2[1:] + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:3] == 'BRX' or method2[0:3] == 'G96': + exc = method2[0:3] + corr = method2[3:] + if exc in xcDict.keys() and corr in xcDict.keys(): + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:5] == 'WPBEH': + exc = method2[0:5] + corr = method2[6:] + if exc in xcDict.keys() and corr in xcDict.keys(): + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:3] == 'LC-': + exccorr = method2[3:] + if exccorr in xcDict.keys(): + xc = 'LC-' + xcDict.get([exccorr][-1]) + if method2 in xcDict.keys(): + xc = method2 + xcWrite= True + methodWrite = True + method = 'DFT' + if method2 in methodDict.keys(): + method = method2 + methodWrite = True + methodreal = method2 + else: + for n in range(2,9): + if method2[0:n] in methodDict.keys(): + method = method2[0:n] + methodWrite = True + methodreal = method2 + if method2[0:n] in xcDict.keys(): + xc = method2[0:n] + xcWrite = True + methodWrite = True + method = 'DFT' + if method2[0:9] == 'CBSEXTRAP': + method = method2[0:9] + methodWrite = True + methodreal = method2 + rest = settings.split('/')[1].replace("'","").replace("]","") + rest = rest.upper() + for x in rest.split(): + if x in basissetDict.keys(): + basisset = x + basissetWrite = True + basissetreal = x + if 'D95' in x: + method2 = x + basisset = method2[0:3] + basissetWrite = True + basissetreal = method2 + if 'AUG-' in x: + method2 = x + basisset = method2[4:] + basissetWrite = True + basissetreal = method2 + if 'UGBS' in x: + method2 = x + basisset = method2[0:4] + basissetWrite = True + basissetreal = method2 + if 'CBSB7' in x: + method2 = x + basisset = method2[0:5] + basissetWrite = True + basissetreal = method2 + if 'LANL1' in x: + method2 = x + basisset = method2[0:5] + basissetWrite = True + basissetreal = method2 + if 'LANL2' in x: + method2 = x + basisset = method2[0:5] + basissetWrite = True + basissetreal = method2 + if '6-31' in x: + method2 = x + if '6-311' in x: + basisset = '6-311G' + basissetWrite = True + basissetreal = '6-311' + method2[5:] + else: + basisset = '6-31G' + basissetWrite = True + basissetreal = '6-31' + method2[4:] + slashes = settings.count('/') + if slashes > 1: + rest2 = settings.split()[1] + rest2 = rest2.upper() + for z in rest2.split('/'): + if z in basissetDict.keys(): + basisset = z + basissetWrite = True + if (len(rest2.split('/')) == 2): + if(basisset is not None): + basissetreal = rest2.split('/')[1] + '/' + basisset + else: + basissetreal = rest2.split('/')[1] + else: + pass + else: + method1 = settings.split() + for x in method1: + method2 = str(x) + method2 = method2.upper() + if method2 != 'RHF' and method2 != 'UHF' and method2 != 'ROHF' and method2 != 'UFF': + if (method2[0] == 'R' and method2[0:2] != 'RO') or method2[0] == 'U': + methodprefix = method2[0] + method2 = method2[1:] + elif method2[0:2] == 'RO': + methodprefix = method2[0:2] + method2 = method2[2:] + if method2[0:2] == 'SV' or method2[0] == 'B' or method2[0] == 'O': + if method2[0] in xcDict.keys() and method2[1:] in xcDict.keys(): + exc = method2[0] + corr = method2[1:] + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:3] == 'BRX' or method2[0:3] == 'G96': + exc = method2[0:3] + corr = method2[3:] + if exc in xcDict.keys() and corr in xcDict.keys(): + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:5] == 'WPBEH': + exc = method2[0:5] + corr = method2[6:] + if exc in xcDict.keys() and corr in xcDict.keys(): + excfunc = xcDict[exc][0]['name'] + corrfunc = xcDict[corr][0]['name'] + xc = str(excfunc) + "_" + str(corrfunc) + if method2[0:3] == 'LC-': + exccorr = method2[3:] + if exccorr in xcDict.keys(): + xc = 'LC-' + xcDict.get([exccorr][-1]) + if method2 in xcDict.keys(): + xc = method2 + xcWrite= True + method = 'DFT' + if method2 in methodDict.keys(): + method = method2 + methodWrite = True + methodreal = method2 + else: + for n in range(2,9): + if method2[0:n] in methodDict.keys(): + method = method2[0:n] + methodWrite = True + methodreal = method2 + if method2[0:9] == 'CBSEXTRAP': + method = method2[0:9] + methodWrite = True + methodreal = method2 + if method2 in basissetDict.keys(): + basisset = method2 + basissetWrite = True + basissetreal = method2 + if 'D95' in method2: + basisset = method2[0:3] + basissetWrite = True + basissetreal = method2 + if 'AUG-' in method2: + basisset = method2[4:] + basissetWrite = True + basissetreal = method2 + if 'UGBS' in method2: + basisset = method2[0:4] + basissetWrite = True + basissetreal = method2 + if 'CBSB7' in method2: + basisset = method2[0:5] + basissetWrite = True + basissetreal = method2 + if '6-31' in method2: + if '6-311' in method2: + basisset = '6-311G' + basissetWrite = True + basissetreal = '6-311' + method2[5:] + else: + basisset = '6-31G' + basissetWrite = True + basissetreal = '6-31' + method2[4:] + +# special options for ONIOM calculations + else: + method = 'ONIOM' + methodWrite = True + method1 = settings.split() + for x in method1: + method2 = str(x) + method2 = method2.upper() + if 'ONIOM' in method2: + methodreal = method2 + +# functionals where hybrid_xc_coeff are written + + if xc is not None: + # check if only one xc keyword was found in output + if len([xc]) > 1: + logger.error("Found %d settings for the xc functional: %s. This leads to an undefined behavior of the calculation and no metadata can be written for xc." % (len(xc), xc)) + else: + backend.superBackend.addValue('x_gaussian_xc', [xc][-1]) + if xcWrite: + # get list of xc components according to parsed value + xcList = xcDict.get([xc][-1]) + if xcList is not None: + # loop over the xc components + for xcItem in xcList: + xcName = xcItem.get('name') + if xcName is not None: + # write section and XC_functional_name + gIndexTmp = backend.openSection('section_XC_functionals') + backend.addValue('XC_functional_name', xcName) + # write hybrid_xc_coeff for PBE1PBE into XC_functional_parameters + backend.closeSection('section_XC_functionals', gIndexTmp) + else: + logger.error("The dictionary for xc functional '%s' does not have the key 'name'. Please correct the dictionary xcDict in %s." % (xc[-1], os.path.basename(__file__))) + else: + logger.error("The xc functional '%s' could not be converted for the metadata. Please add it to the dictionary xcDict in %s." % (xc[-1], os.path.basename(__file__))) + +# Write electronic structure method to metadata + + if method is not None: + # check if only one method keyword was found in output + if len([method]) > 1: + logger.error("Found %d settings for the method: %s. This leads to an undefined behavior of the calculation and no metadata can be written for the method." % (len(method), method)) + else: + backend.superBackend.addValue('x_gaussian_method', [method][-1]) + methodList = methodDict.get([method][-1]) + if methodWrite: + if methodList is not None: + # loop over the method components + for methodItem in methodList: + methodName = methodItem.get('name') + if methodName is not None: + # write section and method name + if methodprefix != None and methodreal != None: + gIndexTmp = backend.openSection('x_gaussian_section_elstruc_method') + backend.addValue('x_gaussian_electronic_structure_method', str(methodprefix) + methodreal) + backend.closeSection('x_gaussian_section_elstruc_method', gIndexTmp) + elif methodreal != None: + gIndexTmp = backend.openSection('x_gaussian_section_elstruc_method') + backend.addValue('x_gaussian_electronic_structure_method', methodreal) + backend.closeSection('x_gaussian_section_elstruc_method', gIndexTmp) + else: + logger.error("The dictionary for method '%s' does not have the key 'name'. Please correct the dictionary methodDict in %s." % (method[-1], os.path.basename(__file__))) + else: + logger.error("The method '%s' could not be converted for the metadata. Please add it to the dictionary methodDict in %s." % (method[-1], os.path.basename(__file__))) + +#Write basis sets to metadata + + if basisset is not None: + # check if only one method keyword was found in output + if len([basisset]) > 1: + logger.error("Found %d settings for the basis set: %s. This leads to an undefined behavior of the calculation and no metadata can be written for the basis set." % (len(method), method)) + else: + backend.superBackend.addValue('basis_set', basisset) + basissetList = basissetDict.get([basisset][-1]) + if basissetWrite: + if basissetList is not None: + # loop over the basis set components + for basissetItem in basissetList: + basissetName = basissetItem.get('name') + if basissetName is not None: + # write section and basis set name(s) + gIndexTmp = backend.openSection('section_basis_set_atom_centered') + backend.addValue('basis_set_atom_centered_short_name', basissetreal) + backend.closeSection('section_basis_set_atom_centered', gIndexTmp) + else: + logger.error("The dictionary for basis set '%s' does not have the key 'name'. Please correct the dictionary basissetDict in %s." % (basisset[-1], os.path.basename(__file__))) + else: + logger.error("The basis set '%s' could not be converted for the metadata. Please add it to the dictionary basissetDict in %s." % (basisset[-1], os.path.basename(__file__))) + + def onClose_x_gaussian_section_hybrid_coeffs(self, backend, gIndex, section): + # assign the coefficients to the hybrid functionals + + hybrid_xc_coeffsa = () + hybrid_xc_coeffsb = () + if(str(section['hybrid_xc_coeff1']) != 'None'): + hybrid_xc_coeffsa = float(str(section['hybrid_xc_coeff1']).replace("[","").replace("]","")) + else: + hybrid_xc_coeffsa = 0.0 + backend.addValue('x_gaussian_hybrid_xc_hfx', hybrid_xc_coeffsa) + hybrid_xc_coeffs = str(section['hybrid_xc_coeff2']) + hybrid_xc_coeffsb = [float(f) for f in hybrid_xc_coeffs[1:].replace("'","").replace("]","").replace("]","").split()] + backend.addValue('x_gaussian_hybrid_xc_slater', hybrid_xc_coeffsb[0]) + backend.addValue('x_gaussian_hybrid_xc_nonlocalex', hybrid_xc_coeffsb[1]) + backend.addValue('x_gaussian_hybrid_xc_localcorr', hybrid_xc_coeffsb[2]) + backend.addValue('x_gaussian_hybrid_xc_nonlocalcorr', hybrid_xc_coeffsb[3]) + + def onClose_section_system(self, backend, gIndex, section): + # write/store unit cell if present and set flag self.periodicCalc + if(section['x_gaussian_geometry_lattice_vector_x']): + unit_cell = [] + for i in ['x', 'y', 'z']: + uci = str(section['x_gaussian_geometry_lattice_vector_' + i]) + uci = uci.split() + for i in range(len(uci)): + uci[i] = str(uci[i]).replace("[","").replace("'","").replace("]","").replace("\"","").replace(",","") + if uci[i] is not None: + uci[i] = float(uci[i]) + if uci is not None: + uci = convert_unit(uci, "angstrom", "m") + unit_cell.append(uci) + if unit_cell: + # from metadata: "The first index is x,y,z and the second index the lattice vector." + # => unit_cell has already the right format + backend.addArrayValues('simulation_cell', np.asarray(unit_cell), gIndex) + if np.shape(unit_cell) == (3, 1): + backend.addArrayValues('configuration_periodic_dimensions', np.asarray([True, False, False]), gIndex) + if np.shape(unit_cell) == (3, 2): + backend.addArrayValues('configuration_periodic_dimensions', np.asarray([True, True, False]), gIndex) + if np.shape(unit_cell) == (3, 3): + backend.addArrayValues('configuration_periodic_dimensions', np.asarray([True, True, True]), gIndex) + self.periodicCalc = True + else: + unit_cell = [[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0]] + backend.addArrayValues('simulation_cell', np.asarray(unit_cell), gIndex) + backend.addArrayValues('configuration_periodic_dimensions', np.asarray([False, False, False]), gIndex) + + if(section["x_gaussian_atomic_masses"]): + atomicmasses = str(section["x_gaussian_atomic_masses"]) + atmass = [] + mass = [float(f) for f in atomicmasses[1:].replace("'","").replace(",","").replace("]","").replace(" ."," 0.").replace(" -."," -0.").split()] + atmass = np.append(atmass, mass) + numberofatoms = len(atmass) + backend.addArrayValues("x_gaussian_masses", atmass, gIndex) + +# which values to cache or forward (mapping meta name -> CachingLevel) + +cachingLevelForMetaName = { + "x_gaussian_atom_x_coord": CachingLevel.Cache, + "x_gaussian_atom_y_coord": CachingLevel.Cache, + "x_gaussian_atom_z_coord": CachingLevel.Cache, + "x_gaussian_atomic_number": CachingLevel.Cache, + "x_gaussian_section_geometry": CachingLevel.Forward, + "x_gaussian_atom_x_force": CachingLevel.Cache, + "x_gaussian_atom_y_force": CachingLevel.Cache, + "x_gaussian_atom_z_force": CachingLevel.Cache, + "x_gaussian_number_of_atoms": CachingLevel.ForwardAndCache, + "section_scf_iteration": CachingLevel.Forward, + "energy_total_scf_iteration": CachingLevel.ForwardAndCache, + "x_gaussian_delta_energy_total_scf_iteration": CachingLevel.ForwardAndCache, + "energy_total": CachingLevel.ForwardAndCache, + "x_gaussian_energy_error": CachingLevel.ForwardAndCache, + "x_gaussian_electronic_kinetic_energy": CachingLevel.ForwardAndCache, + "x_gaussian_energy_electrostatic": CachingLevel.ForwardAndCache, + "x_gaussian_section_frequencies": CachingLevel.Forward, + "x_gaussian_frequency_values": CachingLevel.Cache, + "x_gaussian_frequencies": CachingLevel.ForwardAndCache, + "x_gaussian_reduced_masses": CachingLevel.Cache, + "x_gaussian_red_masses": CachingLevel.ForwardAndCache, + "x_gaussian_normal_modes": CachingLevel.Cache, + "x_gaussian_normal_mode_values": CachingLevel.ForwardAndCache, + "x_gaussian_atomic_masses": CachingLevel.ForwardAndCache, + "x_gaussian_section_force_constant_matrix": CachingLevel.Forward, + "x_gaussian_force_constant_values": CachingLevel.ForwardAndCache, + "x_gaussian_force_constants": CachingLevel.Cache, + "section_eigenvalues": CachingLevel.Forward, + "eigenvalues_values": CachingLevel.ForwardAndCache, + "eigenvalues_occupation": CachingLevel.ForwardAndCache, + "x_gaussian_section_orbital_symmetries": CachingLevel.Forward, + "x_gaussian_alpha_occ_symmetry_values":CachingLevel.Cache, + "x_gaussian_alpha_vir_symmetry_values":CachingLevel.Cache, + "x_gaussian_beta_occ_symmetry_values":CachingLevel.Cache, + "x_gaussian_beta_vir_symmetry_values":CachingLevel.Cache, + "x_gaussian_alpha_symmetries": CachingLevel.ForwardAndCache, + "x_gaussian_beta_symmetries": CachingLevel.ForwardAndCache, + "x_gaussian_section_molecular_multipoles": CachingLevel.Forward, + "dipole_moment_x": CachingLevel.Cache, + "dipole_moment_y": CachingLevel.Cache, + "dipole_moment_z": CachingLevel.Cache, + "quadrupole_moment_xx": CachingLevel.Cache, + "quadrupole_moment_yy": CachingLevel.Cache, + "quadrupole_moment_zz": CachingLevel.Cache, + "quadrupole_moment_xy": CachingLevel.Cache, + "quadrupole_moment_xz": CachingLevel.Cache, + "quadrupole_moment_yz": CachingLevel.Cache, + "octapole_moment_xxx": CachingLevel.Cache, + "octapole_moment_yyy": CachingLevel.Cache, + "octapole_moment_zzz": CachingLevel.Cache, + "octapole_moment_xyy": CachingLevel.Cache, + "octapole_moment_xxy": CachingLevel.Cache, + "octapole_moment_xxz": CachingLevel.Cache, + "octapole_moment_xzz": CachingLevel.Cache, + "octapole_moment_yzz": CachingLevel.Cache, + "octapole_moment_yyz": CachingLevel.Cache, + "octapole_moment_xyz": CachingLevel.Cache, + "hexadecapole_moment_xxxx": CachingLevel.Cache, + "hexadecapole_moment_yyyy": CachingLevel.Cache, + "hexadecapole_moment_zzzz": CachingLevel.Cache, + "hexadecapole_moment_xxxy": CachingLevel.Cache, + "hexadecapole_moment_xxxz": CachingLevel.Cache, + "hexadecapole_moment_yyyx": CachingLevel.Cache, + "hexadecapole_moment_yyyz": CachingLevel.Cache, + "hexadecapole_moment_zzzx": CachingLevel.Cache, + "hexadecapole_moment_zzzy": CachingLevel.Cache, + "hexadecapole_moment_xxyy": CachingLevel.Cache, + "hexadecapole_moment_xxzz": CachingLevel.Cache, + "hexadecapole_moment_yyzz": CachingLevel.Cache, + "hexadecapole_moment_xxyz": CachingLevel.Cache, + "hexadecapole_moment_yyxz": CachingLevel.Cache, + "hexadecapole_moment_zzxy": CachingLevel.Cache, + "x_gaussian_molecular_multipole_values": CachingLevel.ForwardAndCache, + "single_configuration_calculation_converged": CachingLevel.ForwardAndCache, + "x_gaussian_single_configuration_calculation_converged": CachingLevel.ForwardAndCache, + "x_gaussian_section_geometry_optimization_info": CachingLevel.Forward, + "x_gaussian_geometry_optimization_converged": CachingLevel.ForwardAndCache, + "x_gaussian_hf_detect": CachingLevel.ForwardAndCache, + "x_gaussian_section_hybrid_coeffs": CachingLevel.Forward, + "section_method": CachingLevel.Forward, + "x_gaussian_section_elstruc_method": CachingLevel.Forward, + "x_gaussian_electronic_structure_method": CachingLevel.ForwardAndCache, + "XC_functional_name": CachingLevel.ForwardAndCache, + "basis_set_atom_centered_short_name": CachingLevel.Forward, + "x_gaussian_settings": CachingLevel.Cache, + "x_gaussian_settings_corrected": CachingLevel.ForwardAndCache, + "section_system": CachingLevel.Forward, + "x_gaussian_atomic_masses": CachingLevel.ForwardAndCache, + "x_gaussian_masses": CachingLevel.ForwardAndCache, +} + +class GaussianParser(): + """ A proper class envolop for running this parser from within python. """ + def __init__(self, backend, **kwargs): + self.backend_factory = backend + + def parse(self, mainfile): + from unittest.mock import patch + logging.info('gaussian parser started') + logging.getLogger('nomadcore').setLevel(logging.WARNING) + backend = self.backend_factory(metaInfoEnv) + with patch.object(sys, 'argv', ['', '--uri', 'nmd://uri', mainfile]): + mainFunction( + mainFileDescription, + metaInfoEnv, + parserInfo, + cachingLevelForMetaName = cachingLevelForMetaName, + superContext=GaussianParserContext(), + superBackend=backend) + + return backend + +if __name__ == "__main__": + mainFunction(mainFileDescription, metaInfoEnv, parserInfo, + cachingLevelForMetaName = cachingLevelForMetaName, + superContext = GaussianParserContext()) diff --git a/parser/parser-gaussian/setup_paths.py b/gaussianparser/setup_paths.py similarity index 100% rename from parser/parser-gaussian/setup_paths.py rename to gaussianparser/setup_paths.py diff --git a/setup.py b/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..0a88b2f7645eefc575f2e985eded086b70cb79ef --- /dev/null +++ b/setup.py @@ -0,0 +1,33 @@ +# Copyright 2015-2018 Lorenzo Pardini +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from setuptools import setup, find_packages + + +def main(): + setup( + name='gaussianparser', + version='0.1', + description='NOMAD parser implementation for Gaussian.', + license='APACHE 2.0', + package_dir={'': './'}, + packages=find_packages(), + install_requires=[ + 'nomadcore' + ], + ) + + +if __name__ == '__main__': + main() diff --git a/src/test/scala/eu/nomad_lab/parsers/GaussianParserSpec.scala b/src/test/scala/eu/nomad_lab/parsers/GaussianParserSpec.scala deleted file mode 100644 index 6bb014a8656cc2ad8c875fe0c8227c27872b057c..0000000000000000000000000000000000000000 --- a/src/test/scala/eu/nomad_lab/parsers/GaussianParserSpec.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2015-2018 Rosendo Valero, Fawzi Mohamed, Ankit Kariryaa - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package eu.nomad_lab.parsers - -import eu.nomad_lab.{ parsers, DefaultPythonInterpreter } -import org.scalacheck.Properties -import org.specs2.mutable.Specification -import org.{ json4s => jn } - -object GaussianParserSpec extends Specification { - "GaussianParserTest" >> { - "test with Al.out" >> { - "test with json-events" >> { - ParserRun.parse(GaussianParser, "parsers/gaussian/test/examples/Al.out", "json-events") must_== ParseResult.ParseSuccess - } - "test with json" >> { - ParserRun.parse(GaussianParser, "parsers/gaussian/test/examples/Al.out", "json") must_== ParseResult.ParseSuccess - } - } - } -}