Added support for U/R methods and X+C combinations

RaphaelRobidas · RaphaelRobidas · commit 03a5d9b85fa8 · 2022-01-25T12:33:45.000-05:00
Unrestricted or restricted calculations can be specified for Gaussian 16
using the "U" or "R" prefix to the method.

The pure exchange and correlation functionals can be chosen independently
in Gaussian 16.
diff --git a/ccinput/calculation.py b/ccinput/calculation.py
@@ -3,7 +3,7 @@
 
 from ccinput.exceptions import InvalidParameter, InternalError, ImpossibleCalculation, \
                                MissingParameter
-from ccinput.utilities import get_abs_software, get_abs_method, get_abs_basis_set, \
+from ccinput.utilities import get_abs_software, get_method, get_abs_basis_set, \
                               get_abs_solvent, get_theory_level, standardize_memory, \
                               get_npxyz, get_coord
 from ccinput.constants import ATOMIC_NUMBER, SYN_SOFTWARE
@@ -98,30 +98,29 @@ def __init__(self, software, solvent="", solvation_model="",
             solvation_radii="", basis_set="", method="", specifications="",
             density_fitting="", custom_basis_sets="", **kwargs):
 
-        if solvent.strip() != "":
-            self.solvent = get_abs_solvent(solvent)
+        self.solvent = get_abs_solvent(solvent)
+        if self.solvent != "":
             self.solvation_model = solvation_model.lower()
             self.solvation_radii = solvation_radii.lower()
 
             if self.solvation_model.strip() == "":
-                raise InvalidParameter("No solvation model specified, \
-                        although solvation is requested")
+                raise InvalidParameter("No solvation model specified," +
+                            "although solvation is requested")
             if self.solvation_radii.strip() == "":
                 warn("No solvation radii specified; using default radii")
         else:
-            self.solvent = ""
             self.solvation_model = ""
             self.solvation_radii = ""
 
         self.software = get_abs_software(software)
 
         if method == "":
             if 'functional' in kwargs:
-                method = get_abs_method(kwargs['functional'])
+                method = get_method(kwargs['functional'], self.software)
             else:
                 raise InvalidParameter("No calculation method specified (method='...')")
         else:
-            self.method = get_abs_method(method)
+            self.method = get_method(method, self.software)
 
         self.theory_level = get_theory_level(method)
 
diff --git a/ccinput/constants.py b/ccinput/constants.py
@@ -512,6 +512,46 @@ class CalcType(Enum):
         'dlpno-qcisd(t)': ['dlpno-qcisdt', 'dlpnoqcisdt'],
     }
 
+
+
+# Gaussian allows the combination of exchange and correlation functionals
+# without using any special keyword.
+
+EXCHANGE_FUNCTIONALS = {
+        's': 'S',
+        'xa': 'XA',
+        'b': 'B',
+        'pw91': 'PW91',
+        'mpw': 'mPW',
+        'g96': 'G96',
+        'pbe': 'PBE',
+        'o': 'O',
+        'tpss': 'TPSS',
+        'revtpss': 'RevTPSS',
+        'brx': 'BRx',
+        'pkzb': 'PKZB',
+        'wpbeh': 'wPBEh',
+        'pbeh': 'PBEh',
+}
+
+CORRELATION_FUNCTIONALS = {
+        'vwn': 'VWN',
+        'vwn5': 'VWN5',
+        'lyp': 'LYP',
+        'pl': 'PL',
+        'p86': 'P86',
+        'pw91': 'PW91',
+        'b95': 'B95',
+        'pbe': 'PBE',
+        'tpss': 'TPSS',
+        'revtpss': 'RevTPSS',
+        'kcis': 'KCIS',
+        'brc': 'BRC',
+        'pkzb': 'PKZB',
+        'vp86': 'VP86',
+        'v5lyp': 'V5LYP',
+}
+
 SYN_BASIS_SETS = {
         'sto-3g': [],
 
diff --git a/ccinput/packages/orca.py b/ccinput/packages/orca.py
@@ -51,6 +51,11 @@ def __init__(self, calc):
 
         self.create_input_file()
 
+    @property
+    def confirmed_specifications(self):
+        """ Returns the effective additional commands; saved in the Parameters object """
+        return self.additional_commands
+
     def clean(self, s):
         WHITELIST = set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/()=-,. ")
         return ''.join([c for c in s if c in WHITELIST])
diff --git a/ccinput/tests/test_gaussian.py b/ccinput/tests/test_gaussian.py
@@ -3,8 +3,7 @@
 class GaussianTests(InputTests):
 
     def test_sp_SE(self):
-        params = {
-                'nproc': 8,
+        params = { 'nproc': 8,
                 'mem': '10000MB',
                 'type': 'Single-Point Energy',
                 'in_file': 'Cl.xyz',
@@ -2331,3 +2330,206 @@ def test_mem_GB(self):
 
         self.assertTrue(self.is_equivalent(REF, inp.input_file))
 
+    def test_exchange_correlation_functional(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'pkzbpkzb',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp PKZBPKZB/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_exchange_correlation_functional2(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'pBeHpkzb',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp PBEhPKZB/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_restricted_HF(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'rHF',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp RHF/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_unrestricted_HF(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'uHF',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp UHF/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_unknown_HF(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'iHF',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp iHF/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_unrestricted_DFT(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'uM062x',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp UM062X/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
+    def test_restricted_DFT(self):
+        params = {
+                'nproc': 8,
+                'mem': '10GB',
+                'type': 'Single-Point Energy',
+                'in_file': 'Cl.xyz',
+                'software': 'Gaussian',
+                'method': 'rPBE0',
+                'basis_set': '3-21G',
+                'charge': '-1',
+                }
+
+        inp = self.generate_calculation(**params)
+
+        REF = """
+        %chk=calc.chk
+        %nproc=8
+        %mem=10000MB
+        #p sp RPBE1PBE/3-21G
+
+        File created by ccinput
+
+        -1 1
+        Cl 0.0 0.0 0.0
+
+        """
+
+        self.assertTrue(self.is_equivalent(REF, inp.input_file))
+
diff --git a/ccinput/tests/test_orca.py b/ccinput/tests/test_orca.py
@@ -1282,7 +1282,6 @@ def test_hirshfeld_pop(self):
                 }
 
         inp = self.generate_calculation(**params)
-
         REF = """
         !SP M062X Def2-SVP
         *xyz -1 1
diff --git a/ccinput/utilities.py b/ccinput/utilities.py
@@ -191,19 +191,50 @@ def get_abs_basis_set(basis_set):
 
 def get_abs_solvent(solvent):
     _solvent = solvent.strip().lower()
+    if _solvent in ["", "vacuum", "vac"]:
+        return ""
     for solv in SYN_SOLVENTS:
         if _solvent in SYN_SOLVENTS[solv] or _solvent == solv:
             return solv
     raise InvalidParameter(f"Unknown solvent: '{solvent}'")
 
+def is_exchange_correlation_combination(method):
+    for x in EXCHANGE_FUNCTIONALS:
+        if method[:len(x)] == x:
+            if method[len(x):] in CORRELATION_FUNCTIONALS:
+                return EXCHANGE_FUNCTIONALS[method[:len(x)]] + \
+                       CORRELATION_FUNCTIONALS[method[len(x):]]
+    return False
+
 def get_method(method, software):
     try:
         abs_method = get_abs_method(method)
     except InvalidParameter:
+        if software == 'gaussian':
+            # As far as I know, this kind of specification does not apply to ORCA
+            if method.lower()[0] in ['u', 'r']:
+                try:
+                    abs_method = get_abs_method(method[1:])
+                except InvalidParameter:
+                    pass
+                else:
+                    if abs_method not in SOFTWARE_METHODS[software]:
+                        warn(f"Unknown method '{method}'")
+                        return method
+
+                    return method[0].upper() + SOFTWARE_METHODS[software][abs_method]
+
+            xc_check = is_exchange_correlation_combination(method.lower())
+            if isinstance(xc_check, str):
+                return xc_check
         warn(f"Unknown method '{method}'")
         return method
+    else:
+        if abs_method not in SOFTWARE_METHODS[software]:
+            warn(f"Unknown method '{method}'")
+            return method
 
-    return SOFTWARE_METHODS[software][abs_method]
+        return SOFTWARE_METHODS[software][abs_method]
 
 def get_basis_set(basis_set, software):
     try:

Original file line number	Diff line number	Diff line change
`@@ -1282,7 +1282,6 @@ def test_hirshfeld_pop(self):`
`1282`	`1282`	`}`
`1283`	`1283`
`1284`	`1284`	`inp = self.generate_calculation(**params)`
`1285`		`-`
`1286`	`1285`	`REF = """`
`1287`	`1286`	`!SP M062X Def2-SVP`
`1288`	`1287`	`*xyz -1 1`