Added normalization to calc_salc_projection

Added _normalize_salcs_expr() to normalize SALCs from the projection operator method. This simplifies the output from [4*a + 4*b + 4*c] to [a + b + c], for example.

Author: weisscharlesj

chempy/symmetry/salcs.py

@@ -83,6 +83,35 @@ def _expand_irreducible(irred, group):
     return expanded_irred
 
 
+def _normalize_salcs_expr(salcs):
+    """
+    Normalize SALC composed of sympy expresions.
+
+    Normalizes SALC by dividing each SALC through by the largest value in
+    that SALC.
+
+    Parameters
+    ----------
+    salcs : List or nested list of sympy expressions.
+        Nested list of SALCs.
+
+    Returns
+    -------
+    np.array
+
+    """
+    normalized_values = []
+    for salc in salcs:
+        if isinstance(salc, list):
+            normalized_values.append(_normalize_salcs_expr(salc))
+        elif salc == 0:
+            normalized_values.append(salc)
+        else:
+            normalized_values.append(salc.as_poly().monic().as_expr())
+
+    return normalized_values
+
+
 @return_dict
 def calc_salcs_projection(projection, group, to_dict=False):
     """
@@ -116,9 +145,9 @@ def calc_salcs_projection(projection, group, to_dict=False):
     >>> import sympy
     >>> a, b, c = sympy.symbols('a b c')
     >>> calc_salcs_projection([a, b, c, a, b, c], 'c3v')
-    [2*a + 2*b + 2*c, 0, 2*a - b - c]
+    [a + b + c, 0, a - b/2 - c/2]
     >>> calc_salcs_projection([a, b, c, a, b, c], 'c3v', to_dict=True)
-    {'A1': 2*a + 2*b + 2*c, 'A2': 0, 'E': 2*a - b - c}
+    {'A1': a + b + c, 'A2': 0, 'E': a - b/2 - c/2}
 
     """
     salcs = []
@@ -128,7 +157,7 @@ def calc_salcs_projection(projection, group, to_dict=False):
                            np.array(projection))
         salcs.append(np.sum(product))
 
-    return salcs
+    return _normalize_salcs_expr(salcs)
 
 
 # USING SYMMETRY FUNCTIONS

chempy/symmetry/tests/test_salcs.py

@@ -13,42 +13,40 @@ def test_calc_salcs_projection():
     # ammonia hydrogens
     a, b, c = sympy.symbols('a b c')
     assert (calc_salcs_projection([a, b, c, a, b, c], 'c3v') ==
-            [2*a + 2*b + 2*c, 0, 2*a - b - c])
+            [a + b + c, 0, a - b/2 - c/2])
 
     # trigonal bipyramidal
     a1, a2, e1, e2, e3 = sympy.symbols('a1, a2, e1, e2, e3')
     assert (calc_salcs_projection([e1, e2, e3, -e1, -e2, -e3, -e1,
                                    -e2, -e3, e1, e2, e3], 'd3h') ==
-            [0, 0, 0, 0, 4*e1 + 4*e2 + 4*e3, 4*e1 - 2*e2 - 2*e3])
+            [0, 0, 0, 0, e1 + e2 + e3, e1 - e2/2 - e3/2])
     assert (calc_salcs_projection([a1, a1, a1, -a2, -a2, -a2, -a2,
                                    -a2, -a2, a1, a1, a1], 'd3h') ==
-            [6*a1 - 6*a2, 0, 0, 0, 6*a1 + 6*a2, 0])
+            [a1 - a2, 0, 0, 0, a1 + a2, 0])
 
     # square planar s-orbitals
     a, b, c, d = sympy.symbols('a b c d')
     after_trans = [a, b, d, c, c, a, d, b, c, b, d, a, c, a, d, b]
     assert (calc_salcs_projection(after_trans, 'd4h') ==
-            [4*a + 4*b + 4*c + 4*d, 0, 4*a - 4*b + 4*c - 4*d,
-             0, 0, 0, 0, 0, 0, 4*a - 4*c])
+            [a + b + c + d, 0, a - b + c - d, 0, 0, 0, 0, 0, 0, a - c])
 
     # benzene p-orbitals
     a, b, c, d, e, f = sympy.symbols('a b c d e f')
     after_trans = [a, b, f, c, e, d, -a, -c, -e, -b, -d, -f, -d, -c, -e, -b,
                    -f, -a, b, d, f, a, c, e]
     assert (calc_salcs_projection(after_trans, 'd6h') ==
-            [0, 0, 0, 4*a - 4*b + 4*c - 4*d + 4*e - 4*f,
-             4*a + 2*b - 2*c - 4*d - 2*e + 2*f, 0, 0,
-             4*a + 4*b + 4*c + 4*d + 4*e + 4*f, 0, 0, 0,
-             4*a - 2*b - 2*c + 4*d - 2*e - 2*f])
+            [0, 0, 0, a - b + c - d + e - f, a + b/2 - c/2 - d - e/2 + f/2,
+             0, 0, a + b + c + d + e + f, 0, 0, 0,
+             a - b/2 - c/2 + d - e/2 - f/2])
 
     # butadiene p-orbitals - inequivalent p-orbitals are treated separately
     a, b, c, d = sympy.symbols('a b c d')
     after_trans_outer = [a, -d, -a, d]
     after_trans_inner = [b, -c, -b, c]
     assert (calc_salcs_projection(after_trans_outer, 'c2v') ==
-            [0, 2*a - 2*d, 0, 2*a + 2*d])
+            [0, a - d, 0, a + d])
     assert (calc_salcs_projection(after_trans_inner, 'c2v') ==
-            [0, 2*b - 2*c, 0, 2*b + 2*c])
+            [0, b - c, 0, b + c])
 
 
 def test_calc_salcs_func():