the black format test works! formatting 6 files as it suggests

Author: eyoung55

docs/conf.py

@@ -12,33 +12,35 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../pvade'))
+
+sys.path.insert(0, os.path.abspath("../pvade"))
 
 
 # -- Project information -----------------------------------------------------
 
-project = 'PVade'
-copyright = '2023, Walid Arsalane, Ethan Young'
-author = 'Walid Arsalane, Ethan Young'
+project = "PVade"
+copyright = "2023, Walid Arsalane, Ethan Young"
+author = "Walid Arsalane, Ethan Young"
 
 
 # -- General configuration ---------------------------------------------------
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ['sphinx.ext.autodoc',
-              'sphinx.ext.napoleon',
-              'sphinx.ext.autosectionlabel'
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.autosectionlabel",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 
 # -- Options for HTML output -------------------------------------------------
@@ -47,11 +49,11 @@
 # a list of builtin themes.
 #
 # html_theme = 'alabaster'
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
-autoclass_content = 'both'
+autoclass_content = "both"

ns_main.py

@@ -11,10 +11,9 @@
 
 
 def main():
-
     # Get the path to the input file from the command line
     # input_file = get_input_file()
-    input_file = "inputs/2d_cyld.yaml"  #get_input_file()
+    input_file = "inputs/2d_cyld.yaml"  # get_input_file()
 
     # Load the parameters object specified by the input file
     params = SimParams(input_file)

pvade/FlowManager.py

@@ -304,62 +304,90 @@ def _locate_boundary_dofs_tags(self, domain):
         Args:
             domain (:obj:`pvade.geometry.MeshManager.Domain`): A Domain object
 
-        """        
+        """
         self.x_min_V_dofs = dolfinx.fem.locate_dofs_topological(
-            self.V, self.facet_dim, domain.ft.find(domain.domain_markers["x_min"]["idx"])
+            self.V,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["x_min"]["idx"]),
         )
 
         self.x_max_V_dofs = dolfinx.fem.locate_dofs_topological(
-            self.V, self.facet_dim, domain.ft.find(domain.domain_markers["x_max"]["idx"])
+            self.V,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["x_max"]["idx"]),
         )
 
         self.y_min_V_dofs = dolfinx.fem.locate_dofs_topological(
-            self.V, self.facet_dim, domain.ft.find(domain.domain_markers["y_min"]["idx"])
+            self.V,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["y_min"]["idx"]),
         )
 
         self.y_max_V_dofs = dolfinx.fem.locate_dofs_topological(
-            self.V, self.facet_dim, domain.ft.find(domain.domain_markers["y_max"]["idx"])
+            self.V,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["y_max"]["idx"]),
         )
         if self.ndim == 3:
             self.z_min_V_dofs = dolfinx.fem.locate_dofs_topological(
-                self.V, self.facet_dim, domain.ft.find(domain.domain_markers["z_min"]["idx"])
+                self.V,
+                self.facet_dim,
+                domain.ft.find(domain.domain_markers["z_min"]["idx"]),
             )
 
             self.z_max_V_dofs = dolfinx.fem.locate_dofs_topological(
-                self.V, self.facet_dim, domain.ft.find(domain.domain_markers["z_max"]["idx"])
+                self.V,
+                self.facet_dim,
+                domain.ft.find(domain.domain_markers["z_max"]["idx"]),
             )
 
         self.internal_surface_V_dofs = dolfinx.fem.locate_dofs_topological(
-            self.V, self.facet_dim, domain.ft.find(domain.domain_markers["internal_surface"]["idx"])
+            self.V,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["internal_surface"]["idx"]),
         )
 
         self.x_min_Q_dofs = dolfinx.fem.locate_dofs_topological(
-            self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["x_min"]["idx"])
+            self.Q,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["x_min"]["idx"]),
         )
 
         self.x_max_Q_dofs = dolfinx.fem.locate_dofs_topological(
-            self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["x_max"]["idx"])
+            self.Q,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["x_max"]["idx"]),
         )
 
         self.y_min_Q_dofs = dolfinx.fem.locate_dofs_topological(
-            self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["y_min"]["idx"])
+            self.Q,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["y_min"]["idx"]),
         )
 
         self.y_max_Q_dofs = dolfinx.fem.locate_dofs_topological(
-            self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["y_max"]["idx"])
+            self.Q,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["y_max"]["idx"]),
         )
 
         if self.ndim == 3:
             self.z_min_Q_dofs = dolfinx.fem.locate_dofs_topological(
-                self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["z_min"]["idx"])
+                self.Q,
+                self.facet_dim,
+                domain.ft.find(domain.domain_markers["z_min"]["idx"]),
             )
 
             self.z_max_Q_dofs = dolfinx.fem.locate_dofs_topological(
-                self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["z_max"]["idx"])
+                self.Q,
+                self.facet_dim,
+                domain.ft.find(domain.domain_markers["z_max"]["idx"]),
             )
 
         self.internal_surface_Q_dofs = dolfinx.fem.locate_dofs_topological(
-            self.Q, self.facet_dim, domain.ft.find(domain.domain_markers["internal_surface"]["idx"])
+            self.Q,
+            self.facet_dim,
+            domain.ft.find(domain.domain_markers["internal_surface"]["idx"]),
         )
 
     def _applybc(self, value, domain, V, marker):

pvade/geometry/MeshManager3d.py

@@ -32,7 +32,6 @@ def __init__(self, params):
         self._get_domain_markers()
 
     def _get_domain_markers(self):
-
         self.domain_markers = {}
 
         # Facet Markers
@@ -43,13 +42,16 @@ def _get_domain_markers(self):
         self.domain_markers["z_min"] = {"idx": 5, "entity": "facet", "gmsh_tags": []}
         self.domain_markers["z_max"] = {"idx": 6, "entity": "facet", "gmsh_tags": []}
 
-        self.domain_markers["internal_surface"] = {"idx": 7, "entity": "facet", "gmsh_tags": []}
+        self.domain_markers["internal_surface"] = {
+            "idx": 7,
+            "entity": "facet",
+            "gmsh_tags": [],
+        }
 
         # Cell Markers
         self.domain_markers["fluid"] = {"idx": 8, "entity": "cell", "gmsh_tags": []}
         self.domain_markers["structure"] = {"idx": 9, "entity": "cell", "gmsh_tags": []}
 
-
     def build(self, params):
         """This function call builds the geometry, marks the boundaries and creates a mesh using Gmsh."""
 
@@ -62,13 +64,14 @@ def build(self, params):
         except:
             raise ValueError(f"Could not import {domain_creation_module}")
 
-
         self.geometry = dcm.DomainCreation(params)
 
         # Only rank 0 builds the geometry and meshes the domain
         if self.rank == 0:
             self.geometry.build(params)
-            self.domain_markers = self.geometry.mark_surfaces(params, self.domain_markers)
+            self.domain_markers = self.geometry.mark_surfaces(
+                params, self.domain_markers
+            )
             self.geometry.set_length_scales(params, self.domain_markers)
 
             if params.fluid.periodic:

pvade/geometry/template/TemplateDomainCreation.py

@@ -90,24 +90,26 @@ def mark_surfaces(self, params, domain_markers):
             else:
                 domain_markers["internal_surface"]["gmsh_tags"].append(tag)
 
-
         # self.gmsh_model.addPhysicalGroup(self.ndim, [1], domain_marker_idx["fluid"])
         # self.gmsh_model.setPhysicalName(self.ndim, domain_marker_idx["fluid"], "fluid")
-        # TODO: this is a hack to add fluid tags, need to loop through cells 
-        # as we do for facets and mark fluid and structure 
+        # TODO: this is a hack to add fluid tags, need to loop through cells
+        # as we do for facets and mark fluid and structure
         domain_markers["fluid"]["gmsh_tags"].append(1)
 
         for key, data in domain_markers.items():
             if len(data["gmsh_tags"]) > 0:
                 # Cells (i.e., entities of dim = msh.topology.dim)
                 if data["entity"] == "cell":
-                    self.gmsh_model.addPhysicalGroup(self.ndim, data["gmsh_tags"], data["idx"])
+                    self.gmsh_model.addPhysicalGroup(
+                        self.ndim, data["gmsh_tags"], data["idx"]
+                    )
                     self.gmsh_model.setPhysicalName(self.ndim, data["idx"], key)
 
                 # Facets (i.e., entities of dim = msh.topology.dim - 1)
                 if data["entity"] == "facet":
-                    self.gmsh_model.addPhysicalGroup(self.ndim-1, data["gmsh_tags"], data["idx"])
-                    self.gmsh_model.setPhysicalName(self.ndim-1, data["idx"], key)
+                    self.gmsh_model.addPhysicalGroup(
+                        self.ndim - 1, data["gmsh_tags"], data["idx"]
+                    )
+                    self.gmsh_model.setPhysicalName(self.ndim - 1, data["idx"], key)
 
         return domain_markers
-

setup.py

@@ -1,6 +1,8 @@
 from setuptools import setup
 
-setup(name = 'PV Aerodynamic Design Engineering, PVade',
-	version = '0.0',
-	packages = ['pvade'],
-	zip_safe = False)
+setup(
+    name="PV Aerodynamic Design Engineering, PVade",
+    version="0.0",
+    packages=["pvade"],
+    zip_safe=False,
+)