style: apply black to all files in the project

Author: ycexiao

doc/source/conf.py

@@ -223,7 +223,13 @@
 # (source start file, target name, title,
 # author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    ("index", "diffpy.pdfmorph.tex", "diffpy.pdfmorph Documentation", ab_authors, "manual"),
+    (
+        "index",
+        "diffpy.pdfmorph.tex",
+        "diffpy.pdfmorph Documentation",
+        ab_authors,
+        "manual",
+    ),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -251,7 +257,15 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [("index", "diffpy.pdfmorph", "diffpy.pdfmorph Documentation", ab_authors, 1)]
+man_pages = [
+    (
+        "index",
+        "diffpy.pdfmorph",
+        "diffpy.pdfmorph Documentation",
+        ab_authors,
+        1,
+    )
+]
 
 # If true, show URL addresses after external links.
 # man_show_urls = False

src/diffpy/pdfmorph/morph_helpers/__init__.py

@@ -13,8 +13,12 @@
 
 """List of helpers for certain morphing operations (currently only used for smear)."""
 
-from diffpy.pdfmorph.morph_helpers.transformpdftordf import TransformXtalPDFtoRDF
-from diffpy.pdfmorph.morph_helpers.transformrdftopdf import TransformXtalRDFtoPDF
+from diffpy.pdfmorph.morph_helpers.transformpdftordf import (
+    TransformXtalPDFtoRDF,
+)
+from diffpy.pdfmorph.morph_helpers.transformrdftopdf import (
+    TransformXtalRDFtoPDF,
+)
 
 # List of helpers
 morph_helpers = [

src/diffpy/pdfmorph/morph_helpers/transformpdftordf.py

@@ -51,7 +51,9 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         morph_baseline = self.baselineslope * self.x_morph_in
         self.y_morph_out = self.x_morph_in * (self.y_morph_in - morph_baseline)
         target_baseline = self.baselineslope * self.x_target_in
-        self.y_target_out = self.x_target_in * (self.y_target_in - target_baseline)
+        self.y_target_out = self.x_target_in * (
+            self.y_target_in - target_baseline
+        )
         return self.xyallout
 
 

src/diffpy/pdfmorph/morph_helpers/transformrdftopdf.py

@@ -53,10 +53,14 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         morph_baseline = self.baselineslope * self.x_morph_in
         target_baseline = self.baselineslope * self.x_target_in
         with numpy.errstate(divide="ignore", invalid="ignore"):
-            self.y_target_out = self.y_target_in / self.x_target_in + target_baseline
+            self.y_target_out = (
+                self.y_target_in / self.x_target_in + target_baseline
+            )
         self.y_target_out[self.x_target_in == 0] = 0
         with numpy.errstate(divide="ignore", invalid="ignore"):
-            self.y_morph_out = self.y_morph_in / self.x_morph_in + morph_baseline
+            self.y_morph_out = (
+                self.y_morph_in / self.x_morph_in + morph_baseline
+            )
         self.y_morph_out[self.x_target_in == 0] = 0
         return self.xyallout
 

src/diffpy/pdfmorph/morphs/morph.py

@@ -234,7 +234,9 @@ def plotOutputs(self, xylabels=True, **plotargs):
 
         pargs = dict(plotargs)
         pargs.pop("label", None)
-        rv = plot(self.x_target_out, self.y_target_out, label="target", **pargs)
+        rv = plot(
+            self.x_target_out, self.y_target_out, label="target", **pargs
+        )
         rv = plot(self.x_morph_out, self.y_morph_out, label="morph", **pargs)
         if xylabels:
             xlabel(self.xoutlabel)

src/diffpy/pdfmorph/morphs/morphchain.py

@@ -66,19 +66,47 @@ class MorphChain(list):
         The properties return tuples of None if there are no morphs.
     """
 
-    x_morph_in = property(lambda self: None if len(self) == 0 else self[0].x_morph_in)
-    y_morph_in = property(lambda self: None if len(self) == 0 else self[0].y_morph_in)
-    x_target_in = property(lambda self: None if len(self) == 0 else self[0].x_target_in)
-    y_target_in = property(lambda self: None if len(self) == 0 else self[0].y_target_in)
-    x_morph_out = property(lambda self: None if len(self) == 0 else self[-1].x_morph_out)
-    y_morph_out = property(lambda self: None if len(self) == 0 else self[-1].y_morph_out)
-    x_target_out = property(lambda self: None if len(self) == 0 else self[-1].x_target_out)
-    y_target_out = property(lambda self: None if len(self) == 0 else self[-1].y_target_out)
-    xy_morph_in = property(lambda self: (None, None) if len(self) == 0 else self[0].xy_morph_in)
-    xy_morph_out = property(lambda self: (None, None) if len(self) == 0 else self[-1].xy_morph_out)
-    xy_target_in = property(lambda self: (None, None) if len(self) == 0 else self[0].xy_target_in)
-    xy_target_out = property(lambda self: (None, None) if len(self) == 0 else self[-1].xy_target_out)
-    xyallout = property(lambda self: (None, None, None, None) if len(self) == 0 else self[-1].xyallout)
+    x_morph_in = property(
+        lambda self: None if len(self) == 0 else self[0].x_morph_in
+    )
+    y_morph_in = property(
+        lambda self: None if len(self) == 0 else self[0].y_morph_in
+    )
+    x_target_in = property(
+        lambda self: None if len(self) == 0 else self[0].x_target_in
+    )
+    y_target_in = property(
+        lambda self: None if len(self) == 0 else self[0].y_target_in
+    )
+    x_morph_out = property(
+        lambda self: None if len(self) == 0 else self[-1].x_morph_out
+    )
+    y_morph_out = property(
+        lambda self: None if len(self) == 0 else self[-1].y_morph_out
+    )
+    x_target_out = property(
+        lambda self: None if len(self) == 0 else self[-1].x_target_out
+    )
+    y_target_out = property(
+        lambda self: None if len(self) == 0 else self[-1].y_target_out
+    )
+    xy_morph_in = property(
+        lambda self: (None, None) if len(self) == 0 else self[0].xy_morph_in
+    )
+    xy_morph_out = property(
+        lambda self: (None, None) if len(self) == 0 else self[-1].xy_morph_out
+    )
+    xy_target_in = property(
+        lambda self: (None, None) if len(self) == 0 else self[0].xy_target_in
+    )
+    xy_target_out = property(
+        lambda self: (None, None) if len(self) == 0 else self[-1].xy_target_out
+    )
+    xyallout = property(
+        lambda self: (
+            (None, None, None, None) if len(self) == 0 else self[-1].xyallout
+        )
+    )
     parnames = property(lambda self: set(p for m in self for p in m.parnames))
 
     def __init__(self, config, *args):

src/diffpy/pdfmorph/morphs/morphrgrid.py

@@ -63,18 +63,27 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         r_step_target = self.x_target_in[1] - self.x_target_in[0]
         r_step_morph = self.x_morph_in[1] - self.x_morph_in[0]
         rstepinc = max(r_step_target, r_step_morph)
-        rmaxinc = min(self.x_target_in[-1] + r_step_target, self.x_morph_in[-1] + r_step_morph)
+        rmaxinc = min(
+            self.x_target_in[-1] + r_step_target,
+            self.x_morph_in[-1] + r_step_morph,
+        )
         if self.rmin is None or self.rmin < rmininc:
             self.rmin = rmininc
         if self.rmax is None or self.rmax > rmaxinc:
             self.rmax = rmaxinc
         if self.rstep is None or self.rstep < rstepinc:
             self.rstep = rstepinc
         # Make sure that rmax is exclusive
-        self.x_morph_out = numpy.arange(self.rmin, self.rmax - epsilon, self.rstep)
-        self.y_morph_out = numpy.interp(self.x_morph_out, self.x_morph_in, self.y_morph_in)
+        self.x_morph_out = numpy.arange(
+            self.rmin, self.rmax - epsilon, self.rstep
+        )
+        self.y_morph_out = numpy.interp(
+            self.x_morph_out, self.x_morph_in, self.y_morph_in
+        )
         self.x_target_out = self.x_morph_out.copy()
-        self.y_target_out = numpy.interp(self.x_target_out, self.x_target_in, self.y_target_in)
+        self.y_target_out = numpy.interp(
+            self.x_target_out, self.x_target_in, self.y_target_in
+        )
         return self.xyallout
 
 

src/diffpy/pdfmorph/morphs/morphshape.py

@@ -165,15 +165,25 @@ def _spheroidalCF2(r, psize, axrat):
         f1 = (
             1
             - 3 * r / (4 * d * v) * (1 - r2 / (4 * d2) * (1 + 2.0 / (3 * v2)))
-            - 3 * r / (4 * d) * (1 - r2 / (4 * d2)) * v / sqrt(1 - v2) * atanh(sqrt(1 - v2))
+            - 3
+            * r
+            / (4 * d)
+            * (1 - r2 / (4 * d2))
+            * v
+            / sqrt(1 - v2)
+            * atanh(sqrt(1 - v2))
         )
 
         r = rx[numpy.logical_and(rx > v * psize, rx <= psize)]
         r2 = r * r
         f2 = (
             (
                 3 * d / (8 * r) * (1 + r2 / (2 * d2)) * sqrt(1 - r2 / d2)
-                - 3 * r / (4 * d) * (1 - r2 / (4 * d2)) * atanh(sqrt(1 - r2 / d2))
+                - 3
+                * r
+                / (4 * d)
+                * (1 - r2 / (4 * d2))
+                * atanh(sqrt(1 - r2 / d2))
             )
             * v
             / sqrt(1 - v2)
@@ -190,15 +200,26 @@ def _spheroidalCF2(r, psize, axrat):
         f1 = (
             1
             - 3 * r / (4 * d * v) * (1 - r2 / (4 * d2) * (1 + 2.0 / (3 * v2)))
-            - 3 * r / (4 * d) * (1 - r2 / (4 * d2)) * v / sqrt(v2 - 1) * atan(sqrt(v2 - 1))
+            - 3
+            * r
+            / (4 * d)
+            * (1 - r2 / (4 * d2))
+            * v
+            / sqrt(v2 - 1)
+            * atan(sqrt(v2 - 1))
         )
 
         r = rx[numpy.logical_and(rx > psize, rx <= v * psize)]
         r2 = r * r
         f2 = (
             1
             - 3 * r / (4 * d * v) * (1 - r2 / (4 * d2) * (1 + 2.0 / (3 * v2)))
-            - 3.0 / 8 * (1 + r2 / (2 * d2)) * sqrt(1 - d2 / r2) * v / sqrt(v2 - 1)
+            - 3.0
+            / 8
+            * (1 + r2 / (2 * d2))
+            * sqrt(1 - d2 / r2)
+            * v
+            / sqrt(v2 - 1)
             - 3
             * r
             / (4 * d)

src/diffpy/pdfmorph/pdfmorph_api.py

@@ -40,7 +40,9 @@
     ],
     qdamp=morphs.MorphResolutionDamping,
 )
-_default_config = dict(scale=None, stretch=None, smear=None, baselineslope=None, qdamp=None)
+_default_config = dict(
+    scale=None, stretch=None, smear=None, baselineslope=None, qdamp=None
+)
 
 
 def morph_default_config(**kwargs):
@@ -172,7 +174,11 @@ def pdfmorph(
     # input config
     rv_cfg = dict(kwargs)
     # configure morph operations
-    active_morphs = [k for k, v in rv_cfg.items() if (v is not None) and k in _morph_step_dict]
+    active_morphs = [
+        k
+        for k, v in rv_cfg.items()
+        if (v is not None) and k in _morph_step_dict
+    ]
     rv_cfg["rmin"] = rmin
     rv_cfg["rmax"] = rmax
     rv_cfg["rstep"] = rstep
@@ -230,7 +236,9 @@ def pdfmorph(
             print("== INFO: Following steps are fixed during morphing ==:\n")
             print("\n".join(fixed_operations))
         print("== INFO: Refined morph parameters ==:\n")
-        output = "\n".join(["# %s = %f" % (k, v) for k, v in rv_cfg.items() if v is not None])
+        output = "\n".join(
+            ["# %s = %f" % (k, v) for k, v in rv_cfg.items() if v is not None]
+        )
         output += "\n# Rw = %f" % rw
         output += "\n# Pearson = %f" % pcc
         print(output)

src/diffpy/pdfmorph/pdfmorph_io.py

@@ -58,10 +58,17 @@ def single_morph_output(
 
     # Input and output parameters
     morphs_in = "\n# Input morphing parameters:\n"
-    morphs_in += "\n".join(f"# {key} = {morph_inputs[key]}" for key in morph_inputs.keys()) + "\n"
+    morphs_in += (
+        "\n".join(
+            f"# {key} = {morph_inputs[key]}" for key in morph_inputs.keys()
+        )
+        + "\n"
+    )
 
     morphs_out = "# Optimized morphing parameters:\n"
-    morphs_out += "\n".join(f"# {key} = {morph_results[key]:.6f}" for key in morph_results.keys())
+    morphs_out += "\n".join(
+        f"# {key} = {morph_results[key]:.6f}" for key in morph_results.keys()
+    )
 
     # Printing to terminal
     if stdout_flag:
@@ -158,10 +165,20 @@ def get_multisave_names(target_list: list, save_names_file=None, mm=False):
         if target_file.name not in save_names.keys():
             if not mm:
                 save_names.update(
-                    {target_file.name: {__save_morph_as__: f"Morph_with_Target_{target_file.stem}.cgr"}}
+                    {
+                        target_file.name: {
+                            __save_morph_as__: f"Morph_with_Target_{target_file.stem}.cgr"
+                        }
+                    }
                 )
             else:
-                save_names.update({target_file.name: {__save_morph_as__: f"Morph_of_{target_file.stem}.cgr"}})
+                save_names.update(
+                    {
+                        target_file.name: {
+                            __save_morph_as__: f"Morph_of_{target_file.stem}.cgr"
+                        }
+                    }
+                )
     return save_names
 
 
@@ -211,7 +228,9 @@ def multiple_morph_output(
 
     # Input parameters used for every morph
     inputs = "\n# Input morphing parameters:\n"
-    inputs += "\n".join(f"# {key} = {morph_inputs[key]}" for key in morph_inputs.keys())
+    inputs += "\n".join(
+        f"# {key} = {morph_inputs[key]}" for key in morph_inputs.keys()
+    )
 
     # Verbose to get output for every morph
     verbose_outputs = ""
@@ -224,7 +243,8 @@ def multiple_morph_output(
                 output = f"\n# Morph: {target}\n"
             output += "# Optimized morphing parameters:\n"
             output += "\n".join(
-                f"# {param} = {morph_results[target][param]:.6f}" for param in morph_results[target]
+                f"# {param} = {morph_results[target][param]:.6f}"
+                for param in morph_results[target]
             )
             verbose_outputs += f"{output}\n"
 
@@ -270,13 +290,19 @@ def multiple_morph_output(
         else:
             header += f"# from morphing directory {target_path_name}\n"
             header += f"# with target {morph_path_name}"
-        reference_table = Path(save_directory).joinpath("Morph_Reference_Table.txt")
+        reference_table = Path(save_directory).joinpath(
+            "Morph_Reference_Table.txt"
+        )
         with open(reference_table, "w") as reference:
-            print(f"{header}\n{inputs}\n{verbose_outputs}{table}", file=reference)
+            print(
+                f"{header}\n{inputs}\n{verbose_outputs}{table}", file=reference
+            )
 
         if stdout_flag:
             # Indicate successful save
-            save_message = f"# Morphs saved in the directory {save_directory}\n"
+            save_message = (
+                f"# Morphs saved in the directory {save_directory}\n"
+            )
             print(save_message)
 
 
@@ -302,6 +328,10 @@ def tabulate_results(multiple_morph_results):
     tabulated_results = {}
     for param in relevant_parameters:
         tabulated_results.update(
-            {param: tools.get_values_from_dictionary_collection(multiple_morph_results, param)}
+            {
+                param: tools.get_values_from_dictionary_collection(
+                    multiple_morph_results, param
+                )
+            }
         )
     return tabulated_results