Fix code formatting with black and isort

Author: harryswift01

.pre-commit-config.yaml

@@ -15,18 +15,20 @@ repos:
       - id: check-toml
       - id: check-yaml
 
-  - repo: https://github.com/pycqa/flake8
-    rev: 7.1.2
-    hooks:
-      - id: flake8
+  # - repo: https://github.com/pycqa/flake8
+  #   rev: 7.0.0
+  #   hooks:
+  #     - id: flake8
+  #       additional_dependencies: [flake8-pyproject]
 
-  - repo: https://github.com/pycqa/isort/
-    rev: 6.0.1
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
     hooks:
       - id: isort
+        args: ["--profile=black"]
 
-  - repo: https://github.com/PyCQA/pylint
-    rev: v3.3.4
-    hooks:
-      - id: pylint
-        additional_dependencies: ['pylint>=2.16.0']
+  # - repo: https://github.com/PyCQA/pylint
+  #   rev: v3.3.4
+  #   hooks:
+  #     - id: pylint
+  #       additional_dependencies: ['pylint>=2.16.0']

CodeEntropy/ConformationFunctions.py

@@ -1,14 +1,17 @@
 import numpy as nmp
 from MDAnalysis.analysis.dihedrals import Dihedral
 
-def assign_conformation(data_container, dihedral, number_frames, bin_width, start, end, step):
+
+def assign_conformation(
+    data_container, dihedral, number_frames, bin_width, start, end, step
+):
     """
     Create a state vector, showing the state in which the input dihedral is
-    as a function of time. The function creates a histogram from the timeseries of the 
-    dihedral angle values and identifies points of dominant occupancy 
+    as a function of time. The function creates a histogram from the timeseries of the
+    dihedral angle values and identifies points of dominant occupancy
     (called CONVEX TURNING POINTS).
     Based on the identified TPs, states are assigned to each configuration of the dihedral.
-    
+
     Input
     -----
     dihedral_atom_group : the group of 4 atoms defining the dihedral
@@ -21,7 +24,7 @@ def assign_conformation(data_container, dihedral, number_frames, bin_width, star
     Return
     ------
     A timeseries with integer labels describing the state at each point in time.
-    
+
     """
     conformations = nmp.zeros(number_frames)
     phi = nmp.zeros(number_frames)
@@ -37,9 +40,9 @@ def assign_conformation(data_container, dihedral, number_frames, bin_width, star
         phi[timestep.frame] = value
 
     # create a histogram using numpy
-    number_bins = int(360/bin_width)
-    popul, bin_edges = nmp.histogram(a=phi, bins=number_bins, range=(0,360))
-    bin_value = [0.5 * (bin_edges[i] + bin_edges[i+1]) for i in range(0,len(popul))]
+    number_bins = int(360 / bin_width)
+    popul, bin_edges = nmp.histogram(a=phi, bins=number_bins, range=(0, 360))
+    bin_value = [0.5 * (bin_edges[i] + bin_edges[i + 1]) for i in range(0, len(popul))]
 
     # identify "convex turning-points" and populate a list of peaks
     # peak : a bin whose neighboring bins have smaller population
@@ -51,11 +54,19 @@ def assign_conformation(data_container, dihedral, number_frames, bin_width, star
         if popul[bin_index] == 0:
             pass
         # being careful of the last bin (dihedrals have circular symmetry, the histogram does not)
-        elif bin_index == number_bins-1: # the -1 is because the index starts with 0 not 1
-            if popul[bin_index] >= popul[bin_index-1] and popul[bin_index] >= popul[0]:
+        elif (
+            bin_index == number_bins - 1
+        ):  # the -1 is because the index starts with 0 not 1
+            if (
+                popul[bin_index] >= popul[bin_index - 1]
+                and popul[bin_index] >= popul[0]
+            ):
                 peak_values.append(bin_value[bin_index])
         else:
-            if popul[bin_index] >= popul[bin_index-1] and popul[bin_index] >= popul[bin_index+1]:
+            if (
+                popul[bin_index] >= popul[bin_index - 1]
+                and popul[bin_index] >= popul[bin_index + 1]
+            ):
                 peak_values.append(bin_value[bin_index])
 
     # go through each frame again and assign conformation state
@@ -65,4 +76,6 @@ def assign_conformation(data_container, dihedral, number_frames, bin_width, star
         conformations[frame] = nmp.argmin(distances)
 
     return conformations
-#END assign_conformation
+
+
+# END assign_conformation

CodeEntropy/EntropyFunctions.py

@@ -1,26 +1,30 @@
-from ast import arg
-import sys
 import math
+import sys
+from ast import arg
+
+import matplotlib.pyplot as plt
+import MDAnalysis as mda
 import numpy as nmp
-from numpy import linalg as la
 import pandas as pd
-import MDAnalysis as mda
-import matplotlib.pyplot as plt
+from numpy import linalg as la
+
 from CodeEntropy import ConformationFunctions as CONF
 from CodeEntropy import UnitsAndConversions as UAC
-#from CodeEntropy import NeighbourFunctions as NF
 
-def frequency_calculation(lambdas,temp):
+# from CodeEntropy import NeighbourFunctions as NF
+
+
+def frequency_calculation(lambdas, temp):
     """
     Function to calculate an array of vibrational frequencies from the eigenvalues of the
     covariance matrix.
-    
-    Calculated from eq. (3) in Higham, S.-Y. Chou, F. Gräter and  R. H. Henchman, Molecular 
-    Physics, 2018, 116, 1965–1976//eq. (3) in A. Chakravorty, J. Higham and R. H. Henchman, 
+
+    Calculated from eq. (3) in Higham, S.-Y. Chou, F. Gräter and  R. H. Henchman, Molecular
+    Physics, 2018, 116, 1965–1976//eq. (3) in A. Chakravorty, J. Higham and R. H. Henchman,
     J. Chem. Inf. Model., 2020, 60, 5540–5551
-    
+
     frequency=sqrt(λ/kT)/2π
-    
+
     Input
     -----
        lambdas : array of floats - eigenvalues of the covariance matrix
@@ -33,18 +37,21 @@ def frequency_calculation(lambdas,temp):
     pi = nmp.pi
     # get kT in Joules from given temperature
     kT = UAC.get_KT2J(temp)
-    frequencies = 1/(2*pi)*nmp.sqrt(lambdas/kT)
+    frequencies = 1 / (2 * pi) * nmp.sqrt(lambdas / kT)
 
     return frequencies
-#END frequency_calculation
+
+
+# END frequency_calculation
+
 
 def vibrational_entropy(matrix, matrix_type, temp, highest_level):
     """
     Function to calculate the vibrational entropy for each level calculated from eq. (4) in
-    J. Higham, S.-Y. Chou, F. Gräter and R. H. Henchman, Molecular Physics, 2018, 116, 
+    J. Higham, S.-Y. Chou, F. Gräter and R. H. Henchman, Molecular Physics, 2018, 116,
     1965–1976 / eq. (2) in A. Chakravorty, J. Higham and R. H. Henchman,
     J. Chem. Inf. Model., 2020, 60, 5540–5551.
-    
+
     Input
     -----
        matrix : matrix - force/torque covariance matrix
@@ -60,36 +67,43 @@ def vibrational_entropy(matrix, matrix_type, temp, highest_level):
     # Get eigenvalues of the given matrix and change units to SI units
     lambdas = la.eigvals(matrix)
     lambdas = UAC.change_lambda_units(lambdas)
-    
+
     # Calculate frequencies from the eigenvalues
-    frequencies = frequency_calculation(lambdas,temp)
-    
+    frequencies = frequency_calculation(lambdas, temp)
+
     # Sort frequencies lowest to highest
     frequencies = nmp.sort(frequencies)
 
     kT = UAC.get_KT2J(temp)
-    exponent = UAC.PLANCK_CONST*frequencies/kT
-    power_positive = nmp.power(nmp.e,exponent)
-    power_negative = nmp.power(nmp.e,-exponent)
-    S_components = exponent/(power_positive-1) - nmp.log(1-power_negative)
-    S_components = S_components*UAC.GAS_CONST #multiply by R - get entropy in J mol^{-1} K^{-1}
+    exponent = UAC.PLANCK_CONST * frequencies / kT
+    power_positive = nmp.power(nmp.e, exponent)
+    power_negative = nmp.power(nmp.e, -exponent)
+    S_components = exponent / (power_positive - 1) - nmp.log(1 - power_negative)
+    S_components = (
+        S_components * UAC.GAS_CONST
+    )  # multiply by R - get entropy in J mol^{-1} K^{-1}
     # N beads at a level => 3N x 3N covariance matrix => 3N eigenvalues
-    if matrix_type == 'force': #force covariance matrix
-        if highest_level: # whole molecule level - we take all frequencies into account
+    if matrix_type == "force":  # force covariance matrix
+        if highest_level:  # whole molecule level - we take all frequencies into account
             S_vib_total = sum(S_components)
-       
+
         # discard the 6 lowest frequencies to discard translation and rotation of the whole unit
         # the overall translation and rotation of a unit is an internal motion of the level above
         else:
             S_vib_total = sum(S_components[6:])
-    
-    else: #torque covariance matrix - we always take all values into account
+
+    else:  # torque covariance matrix - we always take all values into account
         S_vib_total = sum(S_components)
-    
+
     return S_vib_total
-#END vibrational_entropy
 
-def conformational_entropy(data_container, dihedrals, bin_width, start, end, step, number_frames):
+
+# END vibrational_entropy
+
+
+def conformational_entropy(
+    data_container, dihedrals, bin_width, start, end, step, number_frames
+):
     """
     Function to calculate conformational entropies using eq. (7) in Higham, S.-Y. Chou,
     F. Gräter and R. H. Henchman, Molecular Physics, 2018, 116, 1965–1976 / eq. (4) in
@@ -105,19 +119,21 @@ def conformational_entropy(data_container, dihedrals, bin_width, start, end, ste
        S_conf_total : float - conformational entropy
     """
 
-    S_conf_total=0
+    S_conf_total = 0
 
     # For each dihedral, identify the conformation in each frame
     num_dihedrals = len(dihedrals)
     conformation = nmp.zeros((num_dihedrals, number_frames))
     index = 0
     for dihedral in dihedrals:
-        conformation[index] = CONF.assign_conformation(data_container, dihedral, number_frames, bin_width, start, end, step)
+        conformation[index] = CONF.assign_conformation(
+            data_container, dihedral, number_frames, bin_width, start, end, step
+        )
         index += 1
 
     # For each frame, convert the conformation of all dihedrals into a state string
-    states = ['' for x in range(number_frames)]
-    for frame_index in range (number_frames):
+    states = ["" for x in range(number_frames)]
+    for frame_index in range(number_frames):
         for index in range(num_dihedrals):
             states[frame_index] += str(conformation[index][frame_index])
 
@@ -134,20 +150,23 @@ def conformational_entropy(data_container, dihedrals, bin_width, start, end, ste
     S_conf_total *= -1 * UAC.GAS_CONST
 
     return S_conf_total
-#END conformational_entropy
+
+
+# END conformational_entropy
+
 
 def orientational_entropy(neighbours_dict):
     """
     Function to calculate orientational entropies from eq. (10) in J. Higham, S.-Y. Chou,
     F. Gräter and R. H. Henchman, Molecular Physics, 2018, 116,3 1965–1976. Number of
     orientations, Ω, is calculated using eq. (8) in  J. Higham, S.-Y. Chou, F. Gräter and
-    R. H. Henchman,  Molecular Physics, 2018, 116,3 1965–1976. 
+    R. H. Henchman,  Molecular Physics, 2018, 116,3 1965–1976.
 
     σ is assumed to be 1 for the molecules we're concerned with and hence,
     max {1, (Nc^3*π)^(1/2)} will always be (Nc^3*π)^(1/2).
-    
+
     TODO future release - function for determing symmetry and symmetry numbers maybe?
-    
+
     Input
     -----
       neighbours_dict :  dictionary - dictionary of neighbours for the molecule -
@@ -158,15 +177,21 @@ def orientational_entropy(neighbours_dict):
     -------
        S_or_total : float - orientational entropy
     """
-    S_or_total=0
-    for neighbour in neighbours_dict: #we are going through neighbours
-        if molecule in [] : #water molecules - call POSEIDON functions
-            pass #TODO temporary until function is written
+    S_or_total = 0
+    for neighbour in neighbours_dict:  # we are going through neighbours
+        if molecule in []:  # water molecules - call POSEIDON functions
+            pass  # TODO temporary until function is written
         else:
-            omega= nmp.sqrt((neighbours_dict[molecule]**3)*math.pi) #the bound ligand is always going to be a neighbour
-            S_or_component =math.log(omega) #orientational entropy arising from each neighbouring species - we know the species is going to be a neighbour
-            S_or_component*=UAC.GAS_CONST
-        S_or_total+=S_or_component
-    #TODO for future releases -  implement a case for molecules with hydrogen bonds but to a lesser extent than water
+            omega = nmp.sqrt(
+                (neighbours_dict[molecule] ** 3) * math.pi
+            )  # the bound ligand is always going to be a neighbour
+            S_or_component = math.log(
+                omega
+            )  # orientational entropy arising from each neighbouring species - we know the species is going to be a neighbour
+            S_or_component *= UAC.GAS_CONST
+        S_or_total += S_or_component
+    # TODO for future releases -  implement a case for molecules with hydrogen bonds but to a lesser extent than water
     return S_or_total
-#END orientational_entropy
+
+
+# END orientational_entropy