Adds Formatter to Project

diceplayer/shared/environment/atom.py

@@ -17,15 +17,15 @@ class Atom:
     """
 
     def __init__(
-            self,
-            lbl: int,
-            na: int,
-            rx: float,
-            ry: float,
-            rz: float,
-            chg: float,
-            eps: float,
-            sig: float,
+        self,
+        lbl: int,
+        na: int,
+        rx: float,
+        ry: float,
+        rz: float,
+        chg: float,
+        eps: float,
+        sig: float,
     ) -> None:
         """
         The constructor function __init__ is used to create new instances of the Atom class.

diceplayer/shared/environment/molecule.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
-from diceplayer.shared.utils.ptable import ghost_number
+from diceplayer import logger
 from diceplayer.shared.environment.atom import Atom
 from diceplayer.shared.utils.misc import BOHR2ANG
-from diceplayer import logger
+from diceplayer.shared.utils.ptable import ghost_number
 
-from nptyping import NDArray, Shape, Float
-from numpy.linalg import linalg
 import numpy as np
+from nptyping import Float, NDArray, Shape
+from numpy.linalg import linalg
 
-from typing import List, Any, Tuple, Union
-from copy import deepcopy
 import logging
 import math
+from copy import deepcopy
+from typing import Any, List, Tuple, Union
 
 
 class Molecule:
@@ -127,9 +127,9 @@ class Molecule:
                     dx = atom1.rx - atom2.rx
                     dy = atom1.ry - atom2.ry
                     dz = atom1.rz - atom2.rz
-                    distances.append(math.sqrt(dx ** 2 + dy ** 2 + dz ** 2))
+                    distances.append(math.sqrt(dx**2 + dy**2 + dz**2))
 
-        return np.array(distances).reshape(dim, dim-1)
+        return np.array(distances).reshape(dim, dim - 1)
 
     def inertia_tensor(self) -> NDArray[Shape["3, 3"], Float]:
         """
@@ -147,9 +147,9 @@ class Molecule:
             dy = atom.ry - self.com[1]
             dz = atom.rz - self.com[2]
 
-            Ixx += atom.mass * (dy ** 2 + dz ** 2)
-            Iyy += atom.mass * (dz ** 2 + dx ** 2)
-            Izz += atom.mass * (dx ** 2 + dy ** 2)
+            Ixx += atom.mass * (dy**2 + dz**2)
+            Iyy += atom.mass * (dz**2 + dx**2)
+            Izz += atom.mass * (dx**2 + dy**2)
 
             Ixy += atom.mass * dx * dy * -1
             Ixz += atom.mass * dx * dz * -1
@@ -169,7 +169,9 @@ class Molecule:
         try:
             evals, evecs = linalg.eigh(self.inertia_tensor())
         except ValueError:
-            raise RuntimeError("Error: diagonalization of inertia tensor did not converge")
+            raise RuntimeError(
+                "Error: diagonalization of inertia tensor did not converge"
+            )
 
         return evals, evecs
 
@@ -355,7 +357,7 @@ class Molecule:
             )
         )
 
-    def minimum_distance(self, molec: 'Molecule') -> float:
+    def minimum_distance(self, molec: "Molecule") -> float:
         """
         Return the minimum distance between two molecules
 
@@ -374,6 +376,6 @@ class Molecule:
                         dx = atom1.rx - atom2.rx
                         dy = atom1.ry - atom2.ry
                         dz = atom1.rz - atom2.rz
-                        distances.append(math.sqrt(dx ** 2 + dy ** 2 + dz ** 2))
+                        distances.append(math.sqrt(dx**2 + dy**2 + dz**2))
 
-        return min(distances)
+        return min(distances)

diceplayer/shared/environment/system.py

@@ -1,13 +1,14 @@
-from diceplayer.shared.environment.molecule import Molecule
-from diceplayer.shared.utils.ptable import atomsymb
-from diceplayer.shared.utils.misc import BOHR2ANG
 from diceplayer import logger
+from diceplayer.shared.environment.molecule import Molecule
+from diceplayer.shared.utils.misc import BOHR2ANG
+from diceplayer.shared.utils.ptable import atomsymb
 
-from typing import List, Tuple, TextIO
-from copy import deepcopy
-from numpy import linalg
 import numpy as np
+from numpy import linalg
+
 import math
+from copy import deepcopy
+from typing import List, TextIO, Tuple
 
 
 class System:
@@ -59,7 +60,6 @@ class System:
         logger.info(f"RMSD = {rmsd:>8.5f} Angstrom")
 
     def rmsd_fit(self, p_index: int, r_index: int) -> Tuple[float, Molecule]:
-
         projecting_mol = self.molecule[p_index]
         reference_mol = self.molecule[r_index]
 
@@ -117,9 +117,9 @@ class System:
         rmsd = 0
         for i in range(dim):
             rmsd += (
-                    (x[i, 0] - y[i, 0]) ** 2
-                    + (x[i, 1] - y[i, 1]) ** 2
-                    + (x[i, 2] - y[i, 2]) ** 2
+                (x[i, 0] - y[i, 0]) ** 2
+                + (x[i, 1] - y[i, 1]) ** 2
+                + (x[i, 2] - y[i, 2]) ** 2
             )
         rmsd = math.sqrt(rmsd / dim)
 
@@ -214,12 +214,12 @@ class System:
     #
     def print_charges_and_dipole(self, cycle: int) -> None:
         """
-                Print the charges and dipole of the molecule in the Output file
+        Print the charges and dipole of the molecule in the Output file
 
-                Args:
-                    cycle (int): Number of the cycle
-                    fh (TextIO): Output file
-                """
+        Args:
+            cycle (int): Number of the cycle
+            fh (TextIO): Output file
+        """
 
         logger.info("Cycle # {}\n".format(cycle))
         logger.info("Number of site: {}\n".format(len(self.molecule[0].atom)))
@@ -228,6 +228,10 @@ class System:
 
         logger.info(
             "{:>10.6f}  {:>10.6f}  {:>10.6f}  {:>10.6f}  {:>10.6f}\n".format(
-                chargesAndDipole[0], chargesAndDipole[1], chargesAndDipole[2], chargesAndDipole[3], chargesAndDipole[4]
+                chargesAndDipole[0],
+                chargesAndDipole[1],
+                chargesAndDipole[2],
+                chargesAndDipole[3],
+                chargesAndDipole[4],
             )
         )