Repository: fusion-energy/paramak (language: python)

Issue:
updated to include everyone
## Proposed changes

Updates the citation file to include all code contributors.

## Types of changes

What types of changes does your code introduce to the Paramak?
_Put an `x` in the boxes that apply_

- [ ] Bugfix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Code refactoring
- [x] Documentation Update (if none of the other choices apply)
- [ ] New tests

## Checklist

- [x] Pep8 applied
- [x] Unit tests pass locally with my changes
- [ ] I have added tests that prove my fix is effective or that my feature works
- [x] I have added necessary documentation (if appropriate)



Discussion / hints:

Fix patch:
diff --git a/.circleci/config.yml b/.circleci/config.yml
index a134c6b47..b23167b5b 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -2,69 +2,96 @@
 ##
 # Check https://circleci.com/docs/2.0/language-python/ for more details
 
-version: 2
-jobs:
-  # test:
-  build:
+version: 2.1
+
+executors:
+  paramak:
     docker:
       - image: ghcr.io/fusion-energy/paramak:dependencies
+    resource_class: large
+
+commands:
+  install:
     steps:
-      - checkout
       - run:
-          name: install
+          name: Install
           command: |
             python setup.py install
+  codecov-upload:
+    steps:
+      - run:
+          name: Codecov upload
+          command: bash <(curl -s https://codecov.io/bash)
 
+jobs:
+  # Tests: Utils, Shape, Reactor, Parametric Shapes
+  quick-tests:
+    executor: paramak
+    resource_class: medium
+    steps:
+      - checkout
+      - install
       - run:
           name: run utils tests
-          command: 
-            pytest tests/test_utils.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
-
+          command: pytest tests/test_utils.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
       - run:
           name: run shape tests
-          command:
-            pytest tests/test_shape.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
-
+          command: pytest tests/test_shape.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
       - run:
           name: run Reactor tests
-          command:
-            pytest tests/test_reactor.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
-
+          command: pytest tests/test_reactor.py -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
       - run:
           name: run parametric_shapes tests
-          command:
-            pytest tests/test_parametric_shapes/ -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
+          command: pytest tests/test_parametric_shapes/ -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
+      - store_test_results:
+          path: test-reports
+      - store_artifacts:
+          path: test-reports
+      - codecov-upload
 
+  # Tests: Parametric components
+  parametric-components-tests:
+    executor: paramak
+    resource_class: medium
+    parallelism: 2
+    steps:
+      - checkout
+      - install
       - run:
           name: run parametric_components tests
-          command:
-            pytest tests/test_parametric_components/ -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
+          command: |
+            set -e
+            TEST_FILES=$(circleci tests glob "tests/test_parametric_components/**/*.py" | circleci tests split)
+            pytest -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml $TEST_FILES
+      - store_test_results:
+          path: test-reports
+      - store_artifacts:
+          path: test-reports
+      - codecov-upload
 
+  # Tests: Parametric reactors
+  parametric-reactors-tests:
+    executor: paramak
+    parallelism: 6
+    steps:
+      - checkout
+      - install
       - run:
           name: run parametric_reactors tests
-          command:
-            pytest tests/test_parametric_reactors/ -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml
-
+          command: |
+            set -e
+            TEST_FILES=$(circleci tests glob "tests/test_parametric_reactors/**/*.py" | circleci tests split)
+            pytest -v --cov=paramak --cov-append --cov-report term --cov-report xml --junitxml=test-reports/junit.xml $TEST_FILES
       - store_test_results:
           path: test-reports
-
-      - run: bash <(curl -s https://codecov.io/bash)
+      - store_artifacts:
+          path: test-reports
+      - codecov-upload
 
 workflows:
   version: 2
   test-build-deploy:
     jobs:
-      - build
-      # - test
-      # - build-deploy-master:
-      #     requires:
-      #       - test
-      #     filters:
-      #       branches:
-      #         only: master
-      # - build-deploy-dev:
-      #     requires:
-      #       - test
-      #     filters:
-      #       branches:
-      #         only: develop
+      - quick-tests
+      - parametric-components-tests
+      - parametric-reactors-tests
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e34dae8a1..db93bfbc8 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -18,7 +18,5 @@ _Put an `x` in the boxes that apply_
 
 _Put an `x` in the boxes that apply. You can also fill these out after creating the PR. If you're unsure about any of them, don't hesitate to ask. We're here to help! This is simply a reminder of what we are going to look for before merging your code._
 
-- [ ] Pep8 applied
-- [ ] Unit tests pass locally with my changes
 - [ ] I have added tests that prove my fix is effective or that my feature works
 - [ ] I have added necessary documentation (if appropriate)
diff --git a/.github/workflows/autopep8.yml b/.github/workflows/autopep8.yml
deleted file mode 100644
index 6641dc671..000000000
--- a/.github/workflows/autopep8.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: autopep8
-on: pull_request
-jobs:
-  autopep8:
-    # Check if the PR is not from a fork
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          ref: ${{ github.head_ref }}
-      - name: autopep8
-        id: autopep8
-        uses: peter-evans/autopep8@v1
-        with:
-          args: --exclude=make_faceteted_neutronics_model.py --exit-code --recursive --in-place --aggressive --aggressive .
-      - name: Commit autopep8 changes
-        if: steps.autopep8.outputs.exit-code == 2
-        run: |
-          git config --global user.name 'autopep8'
-          git config --global user.email 'autopep8@users.noreply.github.com'
-          git commit -am "Automated autopep8 fixes"
-          git push
\ No newline at end of file
diff --git a/.github/workflows/black.yml b/.github/workflows/black.yml
new file mode 100644
index 000000000..309e52950
--- /dev/null
+++ b/.github/workflows/black.yml
@@ -0,0 +1,32 @@
+name: black
+
+on:
+  push:
+    paths:
+      - '**.py'
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  black:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: ${{ github.head_ref }}
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+      - name: Install black
+        run: |
+          python -m pip install --upgrade pip
+          pip install black
+      - name: Run black
+        run: |
+          black .
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: "[skip ci] Apply formatting changes"
diff --git a/.github/workflows/docker_publish.yml b/.github/workflows/docker_publish.yml
index 3006790df..461d7f1c3 100644
--- a/.github/workflows/docker_publish.yml
+++ b/.github/workflows/docker_publish.yml
@@ -14,24 +14,31 @@ jobs:
   build_and_push_dependencies:
     runs-on: ubuntu-latest
     steps:
-      -
-        name: Checkout
+      - name: Checkout
         uses: actions/checkout@v2
-      -
-        name: Set up QEMU
+
+      - name: Set up QEMU
         uses: docker/setup-qemu-action@v1
-      -
-        name: Set up Docker Buildx
+
+      - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
-      -
-        name: Login to GitHub Container Registry
+
+      - name: Login to GitHub Container Registry
         uses: docker/login-action@v1
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
-      -
-        name: Build and push Docker image
+
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-single-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-single-buildx
+
+      - name: Build and push dependencies Docker image
         uses: docker/build-push-action@v2
         with:
           push: true
@@ -39,29 +46,18 @@ jobs:
           tags: ghcr.io/fusion-energy/paramak:dependencies
           build-args: |
             cq_version=2.1
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new
 
-  build_and_push_release:
-    runs-on: ubuntu-latest
-    needs: build_and_push_dependencies
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v2
-      -
-        name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      -
-        name: Login to GitHub Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      -
-        name: Build and push Docker image
+      # Temp fix
+      # https://github.com/docker/build-push-action/issues/252
+      # https://github.com/moby/buildkit/issues/1896
+      - name: Move cache
+        run: |
+          rm -rf /tmp/.buildx-cache
+          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+      - name: Build and push final Docker image
         uses: docker/build-push-action@v2
         with:
           push: true
diff --git a/CITATION.cff b/CITATION.cff
index 1269cbe45..6fef4e629 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -10,18 +10,32 @@ authors:
 - family-names: "Delaporte-Mathurin"
   given-names: "Rémi"
   orcid: "https://orcid.org/0000-0003-1064-8882"
-- family-names: "Morbey"
-  given-names: "Declan"
-  orcid: "https://orcid.org/0000-0001-6207-9832"
-- family-names: "Bluteau"
-  given-names: "Matthew"
-  orcid: "https://orcid.org/0000-0001-9498-8475"
+- family-names: "Czentye"
+  given-names: "Máté"
+- family-names: "Hearn"
+  given-names: "Keir"
 - family-names: "Shriwise"
   given-names: "Patrick"
   orcid: "https://orcid.org/0000-0002-3979-7665"
+- family-names: "Taylor"
+  given-names: "Katie"
+- family-names: "Edwards"
+  given-names: "Bruce"
+- family-names: "Bluteau"
+  given-names: "Matthew"
+  orcid: "https://orcid.org/0000-0001-9498-8475"
+- family-names: "Morbey"
+  given-names: "Declan"
+  orcid: "https://orcid.org/0000-0001-6207-9832"
+- family-names: "Hollands"
+  given-names: "Angus"
+- family-names: "Markan
+  given-names: "Zan"  
+- family-names: "Isacs"
+  given-names: "Chris"
 - family-names: "Davis"
-  given-names: "Andrew"
+-  given-names: "Andrew"
 title: "The Paramak: automated parametric geometry construction for fusion reactor designs"
-version: 0.5.1
-date-released: 2021-9-16
+version: 0.6.4
+date-released: 2021-11-30
 url: "https://github.com/fusion-energy/paramak"
diff --git a/Dockerfile b/Dockerfile
index c48707776..aa4d0c376 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -65,7 +65,7 @@ EXPOSE 8888
 WORKDIR /home/paramak
 
 
-FROM ghcr.io/fusion-energy/paramak:dependencies as final
+FROM dependencies as final
 
 COPY run_tests.sh run_tests.sh
 COPY paramak paramak/
diff --git a/conda_build.sh b/conda_build.sh
index 0894281cf..33da8c629 100644
--- a/conda_build.sh
+++ b/conda_build.sh
@@ -22,7 +22,7 @@ rm -rf /tmp/conda-build
 
 
 # VERSION=$(echo $GITHUB_REF | sed 's#.*/v##')
-VERSION=0.6.3
+VERSION=0.6.4
 PLACEHOLDER='version="develop"'
 VERSION_FILE='setup.py'
 # Grep checks that the placeholder is in the file. If grep doesn't find
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 7398f32f9..d034b5d69 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -34,7 +34,7 @@
 
 # If your documentation needs a minimal Sphinx version, state it here.
 #
-needs_sphinx = '4.1.2'
+needs_sphinx = "4.1.2"
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
@@ -135,11 +135,13 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc,
-     "Paramak.tex",
-     "Paramak Documentation",
-     "Paramak contributors",
-     "manual"),
+    (
+        master_doc,
+        "Paramak.tex",
+        "Paramak Documentation",
+        "Paramak contributors",
+        "manual",
+    ),
 ]
 
 
@@ -188,4 +190,4 @@
 
 # -- Extension configuration -------------------------------------------------
 
-html_favicon = 'favicon.ico'
+html_favicon = "favicon.ico"
diff --git a/examples/example_parametric_reactors/render_of_random_reactor.py b/examples/example_parametric_reactors/render_of_random_reactor.py
new file mode 100644
index 000000000..bf01fcb5d
--- /dev/null
+++ b/examples/example_parametric_reactors/render_of_random_reactor.py
@@ -0,0 +1,107 @@
+# This examples creates a 3 by 3 grid of random reactor renders and saves
+# them as a png image
+
+import math
+
+# to run this example you will need all of the following packages installed
+import matplotlib.pyplot as plt
+import numpy as np
+import paramak
+import pyrender
+import trimesh
+
+
+def create_reactor_renders(
+    render_number,
+    inner_blanket_radius,
+    blanket_thickness,
+    blanket_height,
+    lower_blanket_thickness,
+    upper_blanket_thickness,
+    blanket_vv_gap,
+    number_of_images_in_x,
+    number_of_images_in_y,
+):
+
+    # creates a reactor from the input arguments
+    my_reactor = paramak.FlfSystemCodeReactor(
+        rotation_angle=180,
+        inner_blanket_radius=inner_blanket_radius,
+        blanket_thickness=blanket_thickness,
+        blanket_height=blanket_height,
+        lower_blanket_thickness=lower_blanket_thickness,
+        upper_blanket_thickness=upper_blanket_thickness,
+        blanket_vv_gap=blanket_vv_gap,
+        upper_vv_thickness=10,
+        vv_thickness=10,
+        lower_vv_thickness=10,
+    )
+
+    # saves the reactor geometry as separate stl files
+    my_reactor.export_stl()
+
+    # assigns colours to each stl file
+    stl_files_with_colors = {
+        "blanket.stl": (255, 255, 0),
+        "vacuum_vessel.stl": (128, 128, 128),
+        "upper_blanket.stl": (255, 255, 0),
+        "lower_blanket.stl": (255, 255, 0),
+        "lower_vacuum_vessel.stl": (128, 128, 128),
+        "upper_vacuum_vessel.stl": (128, 128, 128),
+    }
+
+    scene = pyrender.Scene()
+
+    # for each stl file and color combination
+    for key, value in stl_files_with_colors.items():
+        trimesh_obj = trimesh.load(key)
+        trimesh_obj.visual.vertex_colors = value
+        trimesh_obj.visual
+
+        render_mesh = pyrender.Mesh.from_trimesh(trimesh_obj, smooth=False)
+        scene.add(render_mesh)
+
+    camera = pyrender.camera.PerspectiveCamera(
+        yfov=math.radians(90.0)  # aspectRatio=2.0 could be added here
+    )
+
+    # sets the position of the camera using a matrix
+    cam = 2 ** -0.5
+    camera_pose = np.array(
+        [[1, 0, 0, 0], [0, cam, -cam, -350], [0, cam, cam, 350], [0, 0, 0, 1]]
+    )
+
+    # adds a camera and a point light source at the same location
+    scene.add(camera, pose=camera_pose)
+    light = pyrender.PointLight(color=np.ones(3), intensity=300000.0)
+    scene.add(light, pose=camera_pose)
+
+    # renders the scene
+    my_render = pyrender.OffscreenRenderer(1000, 1000)
+    color, depth = my_render.render(scene)
+
+    # adds the render to the plot as a subplot in the correct location
+    plt.subplot(number_of_images_in_y, number_of_images_in_x, render_number + 1)
+    plt.axis("off")
+    plt.imshow(color)
+
+
+# creates a blank figure for populating with subplots
+plt.figure()
+
+# loops through adding a random reactor render to the figure with each iteration
+for i in range(4*3):
+    create_reactor_renders(
+        render_number=i,
+        number_of_images_in_x=4,
+        number_of_images_in_y=3,
+        inner_blanket_radius=np.random.uniform(low=50, high=90),
+        blanket_thickness=np.random.uniform(low=50, high=140),
+        blanket_height=np.random.uniform(low=400, high=550),
+        lower_blanket_thickness=np.random.uniform(low=20, high=70),
+        upper_blanket_thickness=np.random.uniform(low=20, high=70),
+        blanket_vv_gap=np.random.uniform(low=10, high=90),
+    )
+
+# saves the plot
+plt.savefig("render.png", dpi=200)
diff --git a/examples/example_parametric_reactors/render_of_random_reactors.py b/examples/example_parametric_reactors/render_of_random_reactors.py
new file mode 100644
index 000000000..ccd44931a
--- /dev/null
+++ b/examples/example_parametric_reactors/render_of_random_reactors.py
@@ -0,0 +1,120 @@
+# This examples creates a 3 by 3 grid of random reactor renders and saves
+# them as a png image
+
+import math
+import random
+
+# to run this example you will need all of the following packages installed
+import matplotlib.pyplot as plt
+import numpy as np
+import paramak
+import pyrender
+import trimesh
+
+
+def generate_random_reactor():
+    all_reactors = [
+        paramak.BallReactor(),
+        paramak.CenterColumnStudyReactor(),
+        paramak.EuDemoFrom2015PaperDiagram(),
+        paramak.FlfSystemCodeReactor(),
+        paramak.IterFrom2020PaperDiagram(),
+        paramak.SegmentedBlanketBallReactor(),
+        paramak.SingleNullBallReactor(),
+        paramak.SingleNullSubmersionTokamak(),
+        paramak.SparcFrom2020PaperDiagram(),
+        paramak.SubmersionTokamak(),
+    ]
+
+    my_reactor = random.choice(all_reactors)
+
+    print(my_reactor)
+
+    input_variables = my_reactor.input_variable_names
+    my_reactor.rotation_angle = 180
+
+    for input_var in [
+        "graveyard_size",
+        "graveyard_offset",
+        "largest_shapes",
+        "elongation",
+        "triangularity",
+        "rotation_angle",
+    ]:
+        try:
+            input_variables.remove(input_var)
+        except:
+            pass
+
+    print(my_reactor.__dict__, "\n\n")
+
+    for input_arg in my_reactor.input_variables:
+        if input_arg in my_reactor.__dict__:
+            if isinstance(my_reactor.__dict__[input_arg], float):
+                rand_scale = random.uniform(0.8, 1.2)
+                setattr(
+                    my_reactor, input_arg, my_reactor.__dict__[input_arg] * rand_scale
+                )
+
+    return my_reactor
+
+
+def create_reactor_renders(
+    render_number, number_of_images_in_x, number_of_images_in_y, reactor
+):
+
+    # saves the reactor geometry as separate stl files
+    reactor.export_stl()
+
+    # assigns colours to each stl file
+
+    scene = pyrender.Scene()
+
+    # for each stl file and color combination
+    for entry in reactor.shapes_and_components:
+        trimesh_obj = trimesh.load(entry.name + ".stl")
+        trimesh_obj.visual.vertex_colors = entry.color
+
+        render_mesh = pyrender.Mesh.from_trimesh(trimesh_obj, smooth=False)
+        scene.add(render_mesh)
+
+    camera = pyrender.camera.PerspectiveCamera(
+        yfov=math.radians(90.0)  # aspectRatio=2.0 could be added here
+    )
+
+    # sets the position of the camera using a matrix
+    cam = 2 ** -0.5
+    camera_pose = np.array(
+        [[1, 0, 0, 0], [0, cam, -cam, -650], [0, cam, cam, 650], [0, 0, 0, 1]]
+    )
+
+    # adds a camera and a point light source at the same location
+    scene.add(camera, pose=camera_pose)
+    light = pyrender.PointLight(color=np.ones(3), intensity=300000.0)
+    scene.add(light, pose=camera_pose)
+
+    # renders the scene
+    my_render = pyrender.OffscreenRenderer(1000, 1000)
+    color, depth = my_render.render(scene)
+
+    # adds the render to the plot as a subplot in the correct location
+    plt.subplot(number_of_images_in_y, number_of_images_in_x, render_number + 1)
+    plt.axis("off")
+    plt.imshow(color)
+    return reactor.reactor_hash_value
+
+
+# creates a blank figure for populating with subplots
+plt.figure()
+
+# loops through adding a random reactor render to the figure with each iteration
+for i in range(4*3):
+    reactor_hash_value = create_reactor_renders(
+        render_number=i,
+        number_of_images_in_x=4,
+        number_of_images_in_y=3,
+        reactor=generate_random_reactor(),
+    )
+
+# saves the plot
+plt.savefig("render_random_reactors.png", dpi=200)
diff --git a/paramak/__init__.py b/paramak/__init__.py
index f6e253b40..b7cd48b2b 100644
--- a/paramak/__init__.py
+++ b/paramak/__init__.py
@@ -24,8 +24,12 @@
 from .parametric_components.tokamak_plasma_from_points import PlasmaFromPoints
 from .parametric_components.tokamak_plasma_plasmaboundaries import PlasmaBoundaries
 
-from .parametric_components.blanket_constant_thickness_arc_h import BlanketConstantThicknessArcH
-from .parametric_components.blanket_constant_thickness_arc_v import BlanketConstantThicknessArcV
+from .parametric_components.blanket_constant_thickness_arc_h import (
+    BlanketConstantThicknessArcH,
+)
+from .parametric_components.blanket_constant_thickness_arc_v import (
+    BlanketConstantThicknessArcV,
+)
 from .parametric_components.blanket_fp import BlanketFP
 from .parametric_components.blanket_poloidal_segment import BlanketFPPoloidalSegments
 
@@ -34,12 +38,20 @@
 
 from .parametric_components.center_column_cylinder import CenterColumnShieldCylinder
 from .parametric_components.center_column_hyperbola import CenterColumnShieldHyperbola
-from .parametric_components.center_column_flat_top_hyperbola import CenterColumnShieldFlatTopHyperbola
-from .parametric_components.center_column_plasma_dependant import CenterColumnShieldPlasmaHyperbola
+from .parametric_components.center_column_flat_top_hyperbola import (
+    CenterColumnShieldFlatTopHyperbola,
+)
+from .parametric_components.center_column_plasma_dependant import (
+    CenterColumnShieldPlasmaHyperbola,
+)
 from .parametric_components.center_column_circular import CenterColumnShieldCircular
-from .parametric_components.center_column_flat_top_circular import CenterColumnShieldFlatTopCircular
+from .parametric_components.center_column_flat_top_circular import (
+    CenterColumnShieldFlatTopCircular,
+)
 
-from .parametric_components.coolant_channel_ring_straight import CoolantChannelRingStraight
+from .parametric_components.coolant_channel_ring_straight import (
+    CoolantChannelRingStraight,
+)
 from .parametric_components.coolant_channel_ring_curved import CoolantChannelRingCurved
 
 from .parametric_components.inboard_firstwall_fccs import InboardFirstwallFCCS
@@ -50,7 +62,9 @@
 from .parametric_components.poloidal_field_coil_case_fc import PoloidalFieldCoilCaseFC
 from .parametric_components.poloidal_field_coil_set import PoloidalFieldCoilSet
 from .parametric_components.poloidal_field_coil_case_set import PoloidalFieldCoilCaseSet
-from .parametric_components.poloidal_field_coil_case_set_fc import PoloidalFieldCoilCaseSetFC
+from .parametric_components.poloidal_field_coil_case_set_fc import (
+    PoloidalFieldCoilCaseSetFC,
+)
 from .parametric_components.extrude_rectangle import ExtrudeRectangle
 
 from .parametric_components.poloidal_segmenter import PoloidalSegments
@@ -67,13 +81,22 @@
 from .parametric_components.inner_tf_coils_circular import InnerTfCoilsCircular
 from .parametric_components.inner_tf_coils_flat import InnerTfCoilsFlat
 
-from .parametric_components.toroidal_field_coil_coat_hanger import ToroidalFieldCoilCoatHanger
-from .parametric_components.toroidal_field_coil_rectangle import ToroidalFieldCoilRectangle
-from .parametric_components.toroidal_field_coil_triple_arc import ToroidalFieldCoilTripleArc
-from .parametric_components.toroidal_field_coil_princeton_d import ToroidalFieldCoilPrincetonD
+from .parametric_components.toroidal_field_coil_coat_hanger import (
+    ToroidalFieldCoilCoatHanger,
+)
+from .parametric_components.toroidal_field_coil_rectangle import (
+    ToroidalFieldCoilRectangle,
+)
+from .parametric_components.toroidal_field_coil_triple_arc import (
+    ToroidalFieldCoilTripleArc,
+)
+from .parametric_components.toroidal_field_coil_princeton_d import (
+    ToroidalFieldCoilPrincetonD,
+)
 from .parametric_components.tf_coil_casing import TFCoilCasing
-from .parametric_components.toroidal_field_coil_round_corners \
-    import ToroidalFieldCoilRectangleRoundCorners
+from .parametric_components.toroidal_field_coil_round_corners import (
+    ToroidalFieldCoilRectangleRoundCorners,
+)
 
 from .parametric_components.vacuum_vessel import VacuumVessel
 from .parametric_components.vacuum_vessel_inner_leg import VacuumVesselInnerLeg
@@ -84,9 +107,13 @@
 from .parametric_reactors.eu_demo_2015_reactor import EuDemoFrom2015PaperDiagram
 from .parametric_reactors.ball_reactor import BallReactor
 from .parametric_reactors.submersion_reactor import SubmersionTokamak
-from .parametric_reactors.single_null_submersion_reactor import SingleNullSubmersionTokamak
+from .parametric_reactors.single_null_submersion_reactor import (
+    SingleNullSubmersionTokamak,
+)
 from .parametric_reactors.single_null_ball_reactor import SingleNullBallReactor
-from .parametric_reactors.segmented_blanket_ball_reactor import SegmentedBlanketBallReactor
+from .parametric_reactors.segmented_blanket_ball_reactor import (
+    SegmentedBlanketBallReactor,
+)
 from .parametric_reactors.center_column_study_reactor import CenterColumnStudyReactor
 from .parametric_reactors.sparc_paper_2020 import SparcFrom2020PaperDiagram
 from .parametric_reactors.iter_paper_2020 import IterFrom2020PaperDiagram
diff --git a/paramak/parametric_components/blanket_constant_thickness_arc_h.py b/paramak/parametric_components/blanket_constant_thickness_arc_h.py
index b0264a7d5..2930e5b56 100644
--- a/paramak/parametric_components/blanket_constant_thickness_arc_h.py
+++ b/paramak/parametric_components/blanket_constant_thickness_arc_h.py
@@ -1,5 +1,5 @@
+from typing import Tuple
 
-from typing import Optional, Tuple
 from paramak import RotateMixedShape
 
 
@@ -54,5 +54,5 @@ def find_points(self):
                 self.inner_upper_point[0] + abs(self.thickness),
                 self.inner_upper_point[1],
                 "straight",
-            )
+            ),
         ]
diff --git a/paramak/parametric_components/blanket_constant_thickness_arc_v.py b/paramak/parametric_components/blanket_constant_thickness_arc_v.py
index 1b2781857..38fea8fb2 100644
--- a/paramak/parametric_components/blanket_constant_thickness_arc_v.py
+++ b/paramak/parametric_components/blanket_constant_thickness_arc_v.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import RotateMixedShape
 
 
@@ -54,5 +54,5 @@ def find_points(self):
                 self.inner_upper_point[0],
                 self.inner_upper_point[1] + abs(self.thickness),
                 "straight",
-            )
+            ),
         ]
diff --git a/paramak/parametric_components/blanket_cutter_parallels.py b/paramak/parametric_components/blanket_cutter_parallels.py
index 44445e0ff..3ff7da8fe 100644
--- a/paramak/parametric_components/blanket_cutter_parallels.py
+++ b/paramak/parametric_components/blanket_cutter_parallels.py
@@ -1,5 +1,5 @@
-
 from typing import Optional
+
 from paramak import ExtrudeStraightShape
 from paramak.utils import cut_solid
 
@@ -28,19 +28,28 @@ def __init__(
         self,
         thickness: float,
         gap_size: float,
-        height: Optional[float] = 2000.,
-        width: Optional[float] = 2000.,
-        azimuth_placement_angle=[0., 36., 72., 108., 144., 180., 216.,
-                                 252., 288., 324.],
+        height: Optional[float] = 2000.0,
+        width: Optional[float] = 2000.0,
+        azimuth_placement_angle=[
+            0.0,
+            36.0,
+            72.0,
+            108.0,
+            144.0,
+            180.0,
+            216.0,
+            252.0,
+            288.0,
+            324.0,
+        ],
         name: Optional[str] = "blanket_cutter_parallels",
         **kwargs
     ) -> None:
 
-        self.main_cutting_shape = \
-            ExtrudeStraightShape(
-                distance=gap_size / 2.0,
-                azimuth_placement_angle=azimuth_placement_angle,
-            )
+        self.main_cutting_shape = ExtrudeStraightShape(
+            distance=gap_size / 2.0,
+            azimuth_placement_angle=azimuth_placement_angle,
+        )
         self.gap_size = gap_size
         self.thickness = thickness
         super().__init__(
@@ -85,7 +94,7 @@ def find_points(self):
             (0, -self.height / 2),
             (self.width, -self.height / 2),
             (self.width, self.height / 2),
-            (0, self.height / 2)
+            (0, self.height / 2),
         ]
 
         self.main_cutting_shape.points = points
diff --git a/paramak/parametric_components/blanket_cutters_star.py b/paramak/parametric_components/blanket_cutters_star.py
index 67ee589a5..679e6ffaa 100644
--- a/paramak/parametric_components/blanket_cutters_star.py
+++ b/paramak/parametric_components/blanket_cutters_star.py
@@ -1,5 +1,5 @@
+from typing import Optional, List, Union
 
-from typing import Optional
 from paramak import ExtrudeStraightShape
 
 
@@ -21,23 +21,25 @@ class BlanketCutterStar(ExtrudeStraightShape):
     """
 
     def __init__(
-            self,
-            distance: float,
-            height: Optional[float] = 2000.,
-            width: Optional[float] = 2000.,
-            azimuth_placement_angle: Optional[float] = [
-                0.,
-                36.,
-                72.,
-                108.,
-                144.,
-                180.,
-                216.,
-                252.,
-                288.,
-                324.],
-            name: Optional[str] = "blanket_cutter_star",
-            **kwargs) -> None:
+        self,
+        distance: float,
+        height: Optional[float] = 2000.0,
+        width: Optional[float] = 2000.0,
+        azimuth_placement_angle: Optional[Union[float, List[float]]] = [
+            0.0,
+            36.0,
+            72.0,
+            108.0,
+            144.0,
+            180.0,
+            216.0,
+            252.0,
+            288.0,
+            324.0,
+        ],
+        name: Optional[str] = "blanket_cutter_star",
+        **kwargs
+    ) -> None:
 
         super().__init__(
             extrude_both=True,
diff --git a/paramak/parametric_components/blanket_fp.py b/paramak/parametric_components/blanket_fp.py
index b7e39de3f..15fa20859 100644
--- a/paramak/parametric_components/blanket_fp.py
+++ b/paramak/parametric_components/blanket_fp.py
@@ -1,16 +1,17 @@
-
 import warnings
 from typing import Callable, List, Optional, Union
 
 import mpmath
 import numpy as np
-import paramak
 import sympy as sp
-from paramak import RotateMixedShape, diff_between_angles
-from paramak.parametric_components.tokamak_plasma_plasmaboundaries import \
-    PlasmaBoundaries
 from scipy.interpolate import interp1d
 
+import paramak
+from paramak import RotateMixedShape, diff_between_angles
+from paramak.parametric_components.tokamak_plasma_plasmaboundaries import (
+    PlasmaBoundaries,
+)
+
 
 class BlanketFP(RotateMixedShape):
     """A blanket volume created from plasma parameters.
@@ -43,21 +44,23 @@ class BlanketFP(RotateMixedShape):
         num_points: number of points that will describe the shape.
     """
 
-    def __init__(self,
-                 thickness,
-                 start_angle: float,
-                 stop_angle: float,
-                 plasma: Optional[Union[paramak.Plasma,
-                                        paramak.PlasmaBoundaries,
-                                        paramak.PlasmaFromPoints]] = None,
-                 minor_radius: Optional[float] = 150.0,
-                 major_radius: Optional[float] = 450.0,
-                 triangularity: Optional[float] = 0.55,
-                 elongation: Optional[float] = 2.0,
-                 vertical_displacement: Optional[float] = 0.0,
-                 offset_from_plasma: Optional[float] = 0.0,
-                 num_points: Optional[int] = 50,
-                 **kwargs):
+    def __init__(
+        self,
+        thickness,
+        start_angle: float,
+        stop_angle: float,
+        plasma: Optional[
+            Union[paramak.Plasma, paramak.PlasmaBoundaries, paramak.PlasmaFromPoints]
+        ] = None,
+        minor_radius: Optional[float] = 150.0,
+        major_radius: Optional[float] = 450.0,
+        triangularity: Optional[float] = 0.55,
+        elongation: Optional[float] = 2.0,
+        vertical_displacement: Optional[float] = 0.0,
+        offset_from_plasma: Optional[float] = 0.0,
+        num_points: Optional[int] = 50,
+        **kwargs
+    ):
 
         super().__init__(**kwargs)
 
@@ -137,23 +140,25 @@ def make_callable(self, attribute):
         # if the attribute is a list, create a interpolated object of the
         # values
         if isinstance(attribute, (tuple, list)):
-            if isinstance(attribute[0], (tuple, list)) and \
-                isinstance(attribute[1], (tuple, list)) and \
-                    len(attribute) == 2:
+            if (
+                isinstance(attribute[0], (tuple, list))
+                and isinstance(attribute[1], (tuple, list))
+                and len(attribute) == 2
+            ):
                 # attribute is a list of 2 lists
                 if len(attribute[0]) != len(attribute[1]):
-                    raise ValueError('The length of angles list must equal \
-                     the length of values list')
+                    raise ValueError(
+                        "The length of angles list must equal \
+                     the length of values list"
+                    )
                 list_of_angles = np.array(attribute[0])
                 offset_values = attribute[1]
             else:
                 # no list of angles is given
                 offset_values = attribute
                 list_of_angles = np.linspace(
-                    self.start_angle,
-                    self.stop_angle,
-                    len(offset_values),
-                    endpoint=True)
+                    self.start_angle, self.stop_angle, len(offset_values), endpoint=True
+                )
             interpolated_values = interp1d(list_of_angles, offset_values)
 
         def fun(theta):
@@ -163,6 +168,7 @@ def fun(theta):
                 return interpolated_values(theta)
             else:
                 return attribute
+
         return fun
 
     def find_points(self, angles=None):
@@ -197,8 +203,10 @@ def outer_offset(theta):
         # assemble
         points = inner_points + outer_points
         if self._overlapping_shape:
-            msg = ("BlanketFP: Some points with negative R coordinate have "
-                   "been ignored.")
+            msg = (
+                "BlanketFP: Some points with negative R coordinate have "
+                "been ignored."
+            )
             warnings.warn(msg)
 
         self.points = points
@@ -243,8 +251,7 @@ def create_offset_points(self, thetas, offset):
             val_R_outer = self.distribution(theta)[0] + offset(theta) * nx
             val_Z_outer = self.distribution(theta)[1] + offset(theta) * ny
             if float(val_R_outer) > 0:
-                points.append(
-                    [float(val_R_outer), float(val_Z_outer), "spline"])
+                points.append([float(val_R_outer), float(val_Z_outer), "spline"])
             else:
                 self._overlapping_shape = True
         return points
diff --git a/paramak/parametric_components/blanket_poloidal_segment.py b/paramak/parametric_components/blanket_poloidal_segment.py
index 259f85380..f8cee6cba 100644
--- a/paramak/parametric_components/blanket_poloidal_segment.py
+++ b/paramak/parametric_components/blanket_poloidal_segment.py
@@ -1,13 +1,12 @@
-
 import warnings
-from typing import List, Optional, Tuple, Union, Callable
+from typing import Callable, List, Optional, Tuple, Union
 
 import numpy as np
-from paramak import BlanketFP, RotateStraightShape
-from paramak.utils import (cut_solid, distance_between_two_points, extend,
-                           rotate)
 from scipy.optimize import minimize
 
+from paramak import BlanketFP, RotateStraightShape
+from paramak.utils import cut_solid, distance_between_two_points, extend, rotate
+
 
 class BlanketFPPoloidalSegments(BlanketFP):
     """Poloidally segmented Blanket inheriting from paramak.BlanketFP.
@@ -54,12 +53,16 @@ def segments_angles(self):
     def segments_angles(self, value):
         if value is not None:
             if self.start_angle is not None or self.stop_angle is not None:
-                msg = "start_angle and stop_angle attributes will be " + \
-                    "ignored if segments_angles is not None"
+                msg = (
+                    "start_angle and stop_angle attributes will be "
+                    + "ignored if segments_angles is not None"
+                )
                 warnings.warn(msg)
             elif self.num_segments is not None:
-                msg = "num_segment attribute will be ignored if " + \
-                    "segments_angles is not None"
+                msg = (
+                    "num_segment attribute will be ignored if "
+                    + "segments_angles is not None"
+                )
                 warnings.warn(msg)
         self._segments_angles = value
 
@@ -90,14 +93,16 @@ def get_angles(self):
         """
         if (self.length_limits, self.nb_segments_limits) != (None, None):
             angles = segments_optimiser(
-                self.length_limits, self.nb_segments_limits,
-                self.distribution, (self.start_angle, self.stop_angle),
-                stop_on_success=True
+                self.length_limits,
+                self.nb_segments_limits,
+                self.distribution,
+                (self.start_angle, self.stop_angle),
+                stop_on_success=True,
             )
         elif self.segments_angles is None:
             angles = np.linspace(
-                self.start_angle, self.stop_angle,
-                num=self.num_segments + 1)
+                self.start_angle, self.stop_angle, num=self.num_segments + 1
+            )
         else:
             angles = self.segments_angles
         return angles
@@ -107,7 +112,7 @@ def find_points(self):
 
         # every points straight connections
         for point in points:
-            point[-1] = 'straight'
+            point[-1] = "straight"
         self.points = points[:-1]
 
     def create_solid(self):
@@ -127,35 +132,33 @@ def create_segment_cutters(self):
             cutting_shape = RotateStraightShape(
                 rotation_angle=self.rotation_angle,
                 azimuth_placement_angle=self.azimuth_placement_angle,
-                union=[])
+                union=[],
+            )
             # add points to the shape to avoid void solid
             cutting_shape.points = [
-                (self.major_radius,
-                 self.vertical_displacement),
-                (self.major_radius +
-                 self.minor_radius /
-                 10,
-                 self.vertical_displacement),
-                (self.major_radius +
-                 self.minor_radius /
-                 10,
-                 self.vertical_displacement +
-                 self.minor_radius /
-                 10),
-                (self.major_radius,
-                 self.vertical_displacement +
-                 self.minor_radius /
-                 10),
+                (self.major_radius, self.vertical_displacement),
+                (
+                    self.major_radius + self.minor_radius / 10,
+                    self.vertical_displacement,
+                ),
+                (
+                    self.major_radius + self.minor_radius / 10,
+                    self.vertical_displacement + self.minor_radius / 10,
+                ),
+                (
+                    self.major_radius,
+                    self.vertical_displacement + self.minor_radius / 10,
+                ),
             ]
 
             # Create cutters for each gap
             for inner_point, outer_point in zip(
-                    self.inner_points[:-1],
-                    self.outer_points[-1::-1]):
+                self.inner_points[:-1], self.outer_points[-1::-1]
+            ):
                 # initialise cutter for gap
                 cutter = RotateStraightShape(
                     rotation_angle=self.rotation_angle,
-                    azimuth_placement_angle=self.azimuth_placement_angle
+                    azimuth_placement_angle=self.azimuth_placement_angle,
                 )
                 # create rectangle of dimension |AB|*2.6 x self.segments_gap
                 A = (inner_point[0], inner_point[1])
@@ -170,20 +173,9 @@ def create_segment_cutters(self):
                 points_cutter = [
                     A,
                     B,
-                    rotate(
-                        B,
-                        extend(
-                            B,
-                            A,
-                            self.segments_gap),
-                        angle=-np.pi / 2),
-                    rotate(
-                        A,
-                        extend(
-                            A,
-                            B,
-                            self.segments_gap),
-                        angle=np.pi / 2)]
+                    rotate(B, extend(B, A, self.segments_gap), angle=-np.pi / 2),
+                    rotate(A, extend(A, B, self.segments_gap), angle=np.pi / 2),
+                ]
                 cutter.points = points_cutter
                 # add cutter to global cutting shape
                 cutting_shape.union.append(cutter)
@@ -191,9 +183,7 @@ def create_segment_cutters(self):
             self.segments_cutters = cutting_shape
 
 
-def compute_lengths_from_angles(
-        angles: List[float],
-        distribution: Callable):
+def compute_lengths_from_angles(angles: List[float], distribution: Callable):
     """Computes the length of segments between a set of points on a (x,y)
     distribution.
 
@@ -215,8 +205,9 @@ def compute_lengths_from_angles(
     return lengths
 
 
-def segments_optimiser(length_limits, nb_segments_limits, distribution, angles,
-                       stop_on_success=True):
+def segments_optimiser(
+    length_limits, nb_segments_limits, distribution, angles, stop_on_success=True
+):
     """Optimiser segmenting a given R(theta), Z(theta) distribution of points
     with constraints regarding the number of segments and the length of the
     segments.
@@ -250,7 +241,7 @@ def segments_optimiser(length_limits, nb_segments_limits, distribution, angles,
     if min_length is None:
         min_length = 0
     if max_length is None:
-        max_length = float('inf')
+        max_length = float("inf")
     if min_nb_segments is None:
         min_nb_segments = 1
     if max_nb_segments is None:
@@ -262,8 +253,7 @@ def segments_optimiser(length_limits, nb_segments_limits, distribution, angles,
     def cost_function(angles):
         angles_with_extremums = [start_angle, *angles, stop_angle]
 
-        lengths = compute_lengths_from_angles(
-            angles_with_extremums, distribution)
+        lengths = compute_lengths_from_angles(angles_with_extremums, distribution)
 
         cost = 0
         for length in lengths:
@@ -276,16 +266,13 @@ def cost_function(angles):
 
     for nb_segments in range(min_nb_segments, max_nb_segments + 1):
         # initialise angles to linspace
-        list_of_angles = \
-            np.linspace(start_angle, stop_angle, num=nb_segments + 1)
+        list_of_angles = np.linspace(start_angle, stop_angle, num=nb_segments + 1)
 
         # use scipy minimize to find best set of angles
-        res = minimize(
-            cost_function, list_of_angles[1:-1], method="Nelder-Mead")
+        res = minimize(cost_function, list_of_angles[1:-1], method="Nelder-Mead")
 
         # complete the optimised angles with extrema
-        optimised_angles = [start_angle] + \
-            [angle for angle in res.x] + [stop_angle]
+        optimised_angles = [start_angle] + list(res.x) + [stop_angle]
 
         # check that the optimised angles meet the lengths requirements
         lengths = compute_lengths_from_angles(optimised_angles, distribution)
diff --git a/paramak/parametric_components/capsule_vacuum_vessel.py b/paramak/parametric_components/capsule_vacuum_vessel.py
index eefbcffb8..e9307269e 100644
--- a/paramak/parametric_components/capsule_vacuum_vessel.py
+++ b/paramak/parametric_components/capsule_vacuum_vessel.py
@@ -1,6 +1,7 @@
+import math
 from typing import Optional, Tuple
+
 from paramak import RotateMixedShape
-import math
 
 
 class CapsuleVacuumVessel(RotateMixedShape):
@@ -20,7 +21,7 @@ def __init__(
         radius: float,
         outer_start_point: Tuple[float, float],
         thickness: float,
-        **kwargs
+        **kwargs,
     ):
         self.radius = radius
         self.thickness = thickness
@@ -35,11 +36,11 @@ def radius(self):
     @radius.setter
     def radius(self, value):
         if not isinstance(value, (float, int)):
-            raise ValueError(
-                'VacuumVessel.radius must be a number. Not', value)
+            raise ValueError("VacuumVessel.radius must be a number. Not", value)
         if value <= 0:
-            msg = ('VacuumVessel.radius must be a positive number above 0. '
-                   f'Not {value}')
+            msg = (
+                "VacuumVessel.radius must be a positive number above 0. " f"Not {value}"
+            )
             raise ValueError(msg)
         self._radius = value
 
@@ -50,11 +51,12 @@ def thickness(self):
     @thickness.setter
     def thickness(self, value):
         if not isinstance(value, (float, int)):
-            msg = f'VacuumVessel.thickness must be a number. Not {value}'
+            msg = f"VacuumVessel.thickness must be a number. Not {value}"
             raise ValueError(msg)
         if value <= 0:
             msg = (
-                f'VacuumVessel.thickness must be a positive number above 0. Not {value}')
+                f"VacuumVessel.thickness must be a positive number above 0. Not {value}"
+            )
             raise ValueError(msg)
         self._thickness = value
 
@@ -70,38 +72,51 @@ def find_points(self):
         top_outer_y = bottom_outer_y + (4 * radius)
         top_outer_x = bottom_outer_x
         inner_r = radius - thickness
-        bottom_outer_x, bottom_outer_y, thickness, radius, top_outer_x, top_outer_y, inner_r = float(bottom_outer_x), float(
-            bottom_outer_y), float(thickness), float(radius), float(top_outer_x), float(top_outer_y), float(inner_r)
+        (
+            bottom_outer_x,
+            bottom_outer_y,
+            thickness,
+            radius,
+            top_outer_x,
+            top_outer_y,
+            inner_r,
+        ) = (
+            float(bottom_outer_x),
+            float(bottom_outer_y),
+            float(thickness),
+            float(radius),
+            float(top_outer_x),
+            float(top_outer_y),
+            float(inner_r),
+        )
 
-        p1 = (bottom_outer_x, bottom_outer_y, 'circle')
-        p3 = (p1[0] + radius, p1[1] + radius, 'straight')
-        p4 = (p3[0], p3[1] + radius * 2, 'circle')
-        p6 = (top_outer_x, top_outer_y, 'straight')
-        p7 = (p6[0], p6[1] - thickness, 'circle')
-        p9 = (p4[0] - thickness, p4[1], 'straight')
-        p10 = (p3[0] - thickness, p3[1], 'circle')
-        p12 = (p1[0], p1[1] + thickness, 'straight')
-        p2 = ((p1[0]) + (radius * math.cos((3 * math.pi) / 8)), (p1[1] +
-                                                                 radius) - (radius * math.sin((3 * math.pi) / 8)), 'circle')
-        p5 = ((p6[0] + (radius * math.cos((2 * math.pi) / 8))), (p6[1] -
-                                                                 radius) + (radius * math.sin((2 * math.pi) / 8)), 'circle')
-        p8 = ((p7[0] + (inner_r * math.cos((2 * math.pi) / 8))), (p7[1] -
-                                                                  inner_r) + (inner_r * math.sin((2 * math.pi) / 8)), 'circle')
-        p11 = ((p12[0]) + (inner_r * math.cos((3 * math.pi) / 8)),
-               (p12[1] + inner_r) - (inner_r * math.sin((3 * math.pi) / 8)),
-               'circle')
+        point_1 = (bottom_outer_x, bottom_outer_y, "circle")
+        point_3 = (point_1[0] + radius, point_1[1] + radius, "straight")
+        point_4 = (point_3[0], point_3[1] + radius * 2, "circle")
+        point_6 = (top_outer_x, top_outer_y, "straight")
+        point_7 = (point_6[0], point_6[1] - thickness, "circle")
+        point_9 = (point_4[0] - thickness, point_4[1], "straight")
+        point_10 = (point_3[0] - thickness, point_3[1], "circle")
+        point_12 = (point_1[0], point_1[1] + thickness, "straight")
+        point_2 = (
+            (point_1[0]) + (radius * math.cos((3 * math.pi) / 8)),
+            (point_1[1] + radius) - (radius * math.sin((3 * math.pi) / 8)),
+            "circle",
+        )
+        p5 = (
+            (point_6[0] + (radius * math.cos((2 * math.pi) / 8))),
+            (point_6[1] - radius) + (radius * math.sin((2 * math.pi) / 8)),
+            "circle",
+        )
+        p8 = (
+            (point_7[0] + (inner_r * math.cos((2 * math.pi) / 8))),
+            (point_7[1] - inner_r) + (inner_r * math.sin((2 * math.pi) / 8)),
+            "circle",
+        )
+        point_11 = (
+            (point_12[0]) + (inner_r * math.cos((3 * math.pi) / 8)),
+            (point_12[1] + inner_r) - (inner_r * math.sin((3 * math.pi) / 8)),
+            "circle",
+        )
 
-        self.points = [
-            p1,
-            p2,
-            p3,
-            p4,
-            p5,
-            p6,
-            p7,
-            p8,
-            p9,
-            p10,
-            p11,
-            p12
-        ]
+        self.points = [point_1, point_2, point_3, point_4, p5, point_6, point_7, p8, point_9, point_10, point_11, point_12]
diff --git a/paramak/parametric_components/center_column_circular.py b/paramak/parametric_components/center_column_circular.py
index 661933003..a83e380b4 100644
--- a/paramak/parametric_components/center_column_circular.py
+++ b/paramak/parametric_components/center_column_circular.py
@@ -1,5 +1,5 @@
+from typing import Optional, Union, Tuple
 
-from typing import Optional, Tuple
 from paramak import RotateMixedShape
 
 
@@ -22,15 +22,13 @@ def __init__(
         inner_radius: float,
         mid_radius: float,
         outer_radius: float,
-        color: Optional[Tuple[float, float, float,
-                              Optional[float]]] = (0., 0.333, 0.),
+        color: Optional[
+            Union[Tuple[float, float, float], Tuple[float, float, float, float]]
+        ] = (0.0, 0.333, 0.0),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            color=color,
-            **kwargs
-        )
+        super().__init__(color=color, **kwargs)
 
         self.height = height
         self.inner_radius = inner_radius
@@ -79,7 +77,7 @@ def find_points(self):
             (self.outer_radius, self.height / 2, "circle"),
             (self.mid_radius, 0, "circle"),
             (self.outer_radius, -self.height / 2, "straight"),
-            (self.inner_radius, -self.height / 2, "straight")
+            (self.inner_radius, -self.height / 2, "straight"),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/center_column_cylinder.py b/paramak/parametric_components/center_column_cylinder.py
index e4e016d9a..70567fc1b 100644
--- a/paramak/parametric_components/center_column_cylinder.py
+++ b/paramak/parametric_components/center_column_cylinder.py
@@ -1,4 +1,5 @@
 from typing import Optional, Tuple
+
 from paramak import RotateStraightShape
 
 
@@ -24,14 +25,10 @@ def __init__(
             0.333,
             0.0,
         ),
-        **kwargs
+        **kwargs,
     ) -> None:
 
-        super().__init__(
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(color=color, name=name, **kwargs)
 
         self.height = height
         self.inner_radius = inner_radius
@@ -45,8 +42,7 @@ def center_height(self):
     @center_height.setter
     def center_height(self, value):
         if not isinstance(value, (int, float)):
-            msg = (
-                f'CenterColumnShieldBlock.center_height should be a float or int. Not a {type(value)}')
+            msg = f"CenterColumnShieldBlock.center_height should be a float or int. Not a {type(value)}"
             raise TypeError(msg)
 
         self._center_height = value
@@ -58,8 +54,7 @@ def height(self):
     @height.setter
     def height(self, value):
         if value is None:
-            raise ValueError(
-                "height of the CenterColumnShieldBlock cannot be None")
+            raise ValueError("height of the CenterColumnShieldBlock cannot be None")
         self._height = value
 
     @property
@@ -70,8 +65,10 @@ def inner_radius(self):
     def inner_radius(self, value):
         if hasattr(self, "outer_radius"):
             if value >= self.outer_radius:
-                msg = (f'inner_radius ({value}) is larger than outer_radius '
-                       '({self.outer_radius})')
+                msg = (
+                    f"inner_radius ({value}) is larger than outer_radius "
+                    "({self.outer_radius})"
+                )
                 raise ValueError(msg)
         self._inner_radius = value
 
@@ -83,15 +80,17 @@ def outer_radius(self):
     def outer_radius(self, value):
         if hasattr(self, "inner_radius"):
             if value <= self.inner_radius:
-                msg = (f'inner_radius ({self.inner_radius}) is larger than '
-                       'outer_radius ({value})')
+                msg = (
+                    f"inner_radius ({self.inner_radius}) is larger than "
+                    "outer_radius ({value})"
+                )
                 raise ValueError(msg)
 
         self._outer_radius = value
 
     def find_points(self):
         """Finds the XZ points joined by straight connections that describe the
-            2D profile of the center column shield shape."""
+        2D profile of the center column shield shape."""
 
         points = [
             (self.inner_radius, self.center_height + self.height / 2),
diff --git a/paramak/parametric_components/center_column_flat_top_circular.py b/paramak/parametric_components/center_column_flat_top_circular.py
index 31fb4d3a6..bace1b484 100644
--- a/paramak/parametric_components/center_column_flat_top_circular.py
+++ b/paramak/parametric_components/center_column_flat_top_circular.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import RotateMixedShape
 
 
@@ -27,16 +27,15 @@ def __init__(
         mid_radius: float,
         outer_radius: float,
         name: Optional[str] = "center_column",
-        color: Optional[Tuple[float, float, float,
-                              Optional[float]]] = (0., 0.333, 0.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.0,
+            0.333,
+            0.0,
+        ),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            color=color,
-            **kwargs
-        )
+        super().__init__(name=name, color=color, **kwargs)
 
         self.height = height
         self.arc_height = arc_height
@@ -96,7 +95,7 @@ def find_points(self):
             (self.mid_radius, 0, "circle"),
             (self.outer_radius, -self.arc_height / 2, "straight"),
             (self.outer_radius, -self.height / 2, "straight"),
-            (self.inner_radius, -self.height / 2, "straight")
+            (self.inner_radius, -self.height / 2, "straight"),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/center_column_flat_top_hyperbola.py b/paramak/parametric_components/center_column_flat_top_hyperbola.py
index fac7f8849..c6646b0fd 100644
--- a/paramak/parametric_components/center_column_flat_top_hyperbola.py
+++ b/paramak/parametric_components/center_column_flat_top_hyperbola.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import RotateMixedShape
 
 
@@ -27,16 +27,15 @@ def __init__(
         mid_radius: float,
         outer_radius: float,
         name: Optional[str] = "center_column",
-        color: Optional[Tuple[float, float, float,
-                              Optional[float]]] = (0., 0.333, 0.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.0,
+            0.333,
+            0.0,
+        ),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            color=color,
-            **kwargs
-        )
+        super().__init__(name=name, color=color, **kwargs)
 
         self.height = height
         self.arc_height = arc_height
@@ -89,12 +88,16 @@ def find_points(self):
         describe the 2D profile of the center column shield shape."""
 
         if not self.inner_radius <= self.mid_radius <= self.outer_radius:
-            raise ValueError('inner_radius must be less than mid_radius. \
-                mid_radius must be less than outer_radius.')
+            raise ValueError(
+                "inner_radius must be less than mid_radius. \
+                mid_radius must be less than outer_radius."
+            )
 
         if self.arc_height >= self.height:
-            msg = ('arc_height ({self.arc_height}) is larger than height '
-                   '({self.height})')
+            msg = (
+                "arc_height ({self.arc_height}) is larger than height "
+                "({self.height})"
+            )
             raise ValueError(msg)
 
         points = [
@@ -105,7 +108,7 @@ def find_points(self):
             (self.mid_radius, 0, "spline"),
             (self.outer_radius, -self.arc_height / 2, "straight"),
             (self.outer_radius, -self.height / 2, "straight"),
-            (self.inner_radius, -self.height / 2, "straight")
+            (self.inner_radius, -self.height / 2, "straight"),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/center_column_hyperbola.py b/paramak/parametric_components/center_column_hyperbola.py
index ba523d88a..6945d0b1c 100644
--- a/paramak/parametric_components/center_column_hyperbola.py
+++ b/paramak/parametric_components/center_column_hyperbola.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import RotateMixedShape
 
 
@@ -23,16 +23,15 @@ def __init__(
         mid_radius: float,
         outer_radius: float,
         name: Optional[str] = "center_column",
-        color: Optional[Tuple[float, float, float,
-                              Optional[float]]] = (0., 0.333, 0.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.0,
+            0.333,
+            0.0,
+        ),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            color=color,
-            **kwargs
-        )
+        super().__init__(name=name, color=color, **kwargs)
 
         self.height = height
         self.inner_radius = inner_radius
@@ -76,8 +75,10 @@ def find_points(self):
         describe the 2D profile of the center column shield shape."""
 
         if not self.inner_radius <= self.mid_radius <= self.outer_radius:
-            raise ValueError("inner_radius must be less than mid radius. \
-                mid_radius must be less than outer_radius.")
+            raise ValueError(
+                "inner_radius must be less than mid radius. \
+                mid_radius must be less than outer_radius."
+            )
 
         points = [
             (self.inner_radius, 0, "straight"),
@@ -85,7 +86,7 @@ def find_points(self):
             (self.outer_radius, self.height / 2, "spline"),
             (self.mid_radius, 0, "spline"),
             (self.outer_radius, -self.height / 2, "straight"),
-            (self.inner_radius, -self.height / 2, "straight")
+            (self.inner_radius, -self.height / 2, "straight"),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/center_column_plasma_dependant.py b/paramak/parametric_components/center_column_plasma_dependant.py
index 3f70dcebf..e1d2be60c 100644
--- a/paramak/parametric_components/center_column_plasma_dependant.py
+++ b/paramak/parametric_components/center_column_plasma_dependant.py
@@ -1,5 +1,5 @@
-
 from typing import Optional
+
 from paramak import Plasma, RotateMixedShape
 
 
@@ -32,7 +32,7 @@ def __init__(
         minor_radius: Optional[float] = 150.0,
         triangularity: Optional[float] = 0.55,
         elongation: Optional[float] = 2.0,
-        **kwargs
+        **kwargs,
     ) -> None:
 
         super().__init__(**kwargs)
@@ -125,38 +125,28 @@ def find_points(self):
 
         plasma_height = abs(plasma.high_point[1]) + abs(plasma.low_point[1])
         if self.height <= plasma_height:
-            msg = (f'Center column height ({self.height}) is smaller than '
-                   'plasma height ({plasma_height}')
+            msg = (
+                f"Center column height ({self.height}) is smaller than "
+                "plasma height ({plasma_height}"
+            )
             raise ValueError(msg)
 
-        if self.inner_radius >= plasma.inner_equatorial_point[0] - \
-                self.mid_offset:
+        if self.inner_radius >= plasma.inner_equatorial_point[0] - self.mid_offset:
             raise ValueError("Inner radius is too large")
 
         points = [
             (self.inner_radius, 0, "straight"),
             (self.inner_radius, self.height / 2, "straight"),
-            (
-                plasma.high_point[0] - self.edge_offset,
-                self.height / 2, "straight"
-            ),
-            (
-                plasma.high_point[0] - self.edge_offset,
-                plasma.high_point[1], "spline"
-            ),
+            (plasma.high_point[0] - self.edge_offset, self.height / 2, "straight"),
+            (plasma.high_point[0] - self.edge_offset, plasma.high_point[1], "spline"),
             (
                 plasma.inner_equatorial_point[0] - self.mid_offset,
                 plasma.inner_equatorial_point[1],
                 "spline",
             ),
-            (
-                plasma.low_point[0] - self.edge_offset,
-                plasma.low_point[1], "straight"),
-            (
-                plasma.low_point[0] - self.edge_offset,
-                -1 * self.height / 2, "straight"
-            ),
-            (self.inner_radius, -1 * self.height / 2, "straight")
+            (plasma.low_point[0] - self.edge_offset, plasma.low_point[1], "straight"),
+            (plasma.low_point[0] - self.edge_offset, -1 * self.height / 2, "straight"),
+            (self.inner_radius, -1 * self.height / 2, "straight"),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/coolant_channel_ring_curved.py b/paramak/parametric_components/coolant_channel_ring_curved.py
index 8c8e2a2f8..5c1057ba9 100644
--- a/paramak/parametric_components/coolant_channel_ring_curved.py
+++ b/paramak/parametric_components/coolant_channel_ring_curved.py
@@ -1,6 +1,7 @@
-
 from typing import Optional
+
 import numpy as np
+
 from paramak import SweepCircleShape
 
 
@@ -41,11 +42,7 @@ def __init__(
         self.height = height
         self.start_angle = start_angle
 
-        super().__init__(
-            path_points=self.path_points,
-            radius=channel_radius,
-            **kwargs
-        )
+        super().__init__(path_points=self.path_points, radius=channel_radius, **kwargs)
 
         self.channel_radius = channel_radius
         self.number_of_coolant_channels = number_of_coolant_channels
@@ -77,7 +74,9 @@ def find_azimuth_placement_angle(self):
                 0 + self.start_angle,
                 360 + self.start_angle,
                 self.number_of_coolant_channels,
-                endpoint=False))
+                endpoint=False,
+            )
+        )
 
         self.azimuth_placement_angle = angles
 
@@ -86,7 +85,7 @@ def find_path_points(self):
         path_points = [
             (self.ring_radius, -self.height / 2),
             (self.ring_radius + self.mid_offset, 0),
-            (self.ring_radius, self.height / 2)
+            (self.ring_radius, self.height / 2),
         ]
 
         self.path_points = path_points
diff --git a/paramak/parametric_components/coolant_channel_ring_straight.py b/paramak/parametric_components/coolant_channel_ring_straight.py
index 5df605a8f..9f7c6bd13 100644
--- a/paramak/parametric_components/coolant_channel_ring_straight.py
+++ b/paramak/parametric_components/coolant_channel_ring_straight.py
@@ -1,6 +1,7 @@
-
 from typing import Optional
+
 import numpy as np
+
 from paramak import ExtrudeCircleShape
 
 
@@ -31,11 +32,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=height,
-            radius=channel_radius,
-            **kwargs
-        )
+        super().__init__(distance=height, radius=channel_radius, **kwargs)
 
         self.height = height
         self.channel_radius = channel_radius
@@ -61,7 +58,9 @@ def find_azimuth_placement_angle(self):
                 0 + self.start_angle,
                 360 + self.start_angle,
                 self.number_of_coolant_channels,
-                endpoint=False))
+                endpoint=False,
+            )
+        )
 
         self.azimuth_placement_angle = angles
 
diff --git a/paramak/parametric_components/cutting_wedge.py b/paramak/parametric_components/cutting_wedge.py
index aaeb9375b..3ac93e4c3 100644
--- a/paramak/parametric_components/cutting_wedge.py
+++ b/paramak/parametric_components/cutting_wedge.py
@@ -1,5 +1,5 @@
-
 from typing import Optional
+
 from paramak import RotateStraightShape
 
 
@@ -21,10 +21,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            rotation_angle=rotation_angle,
-            **kwargs
-        )
+        super().__init__(rotation_angle=rotation_angle, **kwargs)
 
         self.height = height
         self.radius = radius
@@ -51,7 +48,7 @@ def find_points(self):
             (0, self.height / 2),
             (self.radius, self.height / 2),
             (self.radius, -self.height / 2),
-            (0, -self.height / 2)
+            (0, -self.height / 2),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/cutting_wedge_fs.py b/paramak/parametric_components/cutting_wedge_fs.py
index 218ccdf93..71e9e62eb 100644
--- a/paramak/parametric_components/cutting_wedge_fs.py
+++ b/paramak/parametric_components/cutting_wedge_fs.py
@@ -1,4 +1,3 @@
-
 from collections.abc import Iterable
 from operator import itemgetter
 
@@ -16,17 +15,9 @@ class CuttingWedgeFS(CuttingWedge):
             height and radius of the wedge
     """
 
-    def __init__(
-        self,
-        shape,
-        **kwargs
-    ):
+    def __init__(self, shape, **kwargs):
         self.shape = shape
-        super().__init__(
-            height=self.height,
-            radius=self.radius,
-            **kwargs
-        )
+        super().__init__(height=self.height, radius=self.radius, **kwargs)
 
     @property
     def shape(self):
@@ -35,8 +26,10 @@ def shape(self):
     @shape.setter
     def shape(self, value):
         if value.rotation_angle == 360:
-            msg = ('cutting_wedge cannot be created, rotation_angle must be '
-                   'less than 360 degrees')
+            msg = (
+                "cutting_wedge cannot be created, rotation_angle must be "
+                "less than 360 degrees"
+            )
             raise ValueError(msg)
         self._shape = value
 
@@ -94,8 +87,9 @@ def azimuth_placement_angle(self):
         if isinstance(self.shape.azimuth_placement_angle, Iterable):
             self.azimuth_placement_angle = self.shape.rotation_angle
         else:
-            self.azimuth_placement_angle = \
+            self.azimuth_placement_angle = (
                 self.shape.azimuth_placement_angle + self.shape.rotation_angle
+            )
         return self._azimuth_placement_angle
 
     @azimuth_placement_angle.setter
@@ -105,23 +99,26 @@ def azimuth_placement_angle(self, value):
     def find_radius_height(self):
         shape = self.shape
         if shape.rotation_angle == 360:
-            msg = ('cutting_wedge cannot be created, rotation_angle must be '
-                   'less than 360 degrees')
+            msg = (
+                "cutting_wedge cannot be created, rotation_angle must be "
+                "less than 360 degrees"
+            )
             raise ValueError(msg)
         shape_points = shape.points
-        if hasattr(shape, 'radius') and len(shape_points) == 1:
+        if hasattr(shape, "radius") and len(shape_points) == 1:
             max_x = shape_points[0][0] + shape.radius
             max_y = shape_points[0][1] + shape.radius
 
         elif len(shape_points) > 1:
             max_x = max(shape_points, key=itemgetter(0))[0]
-            if shape.get_rotation_axis()[1] not in shape.workplane and \
-                    hasattr(shape, "distance"):
+            if shape.get_rotation_axis()[1] not in shape.workplane and hasattr(
+                shape, "distance"
+            ):
                 max_y = shape.distance
             else:
                 max_y = max(shape_points, key=itemgetter(1))[1]
 
         else:
-            raise ValueError('cutting_wedge cannot be created')
+            raise ValueError("cutting_wedge cannot be created")
         self.radius = SAFETY_FACTOR * max_x
         self.height = SAFETY_FACTOR * max_y
diff --git a/paramak/parametric_components/divertor_ITER.py b/paramak/parametric_components/divertor_ITER.py
index a47d481d1..ab1dc54ab 100644
--- a/paramak/parametric_components/divertor_ITER.py
+++ b/paramak/parametric_components/divertor_ITER.py
@@ -1,9 +1,8 @@
-
 import math
 
 import numpy as np
-from paramak import (RotateMixedShape, distance_between_two_points, extend,
-                     rotate)
+
+from paramak import RotateMixedShape, distance_between_two_points, extend, rotate
 
 
 class ITERtypeDivertor(RotateMixedShape):
@@ -50,9 +49,7 @@ def __init__(
         **kwargs
     ):
 
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
         self.ivt_anchor, self.ovt_anchor = anchors
         self.ivt_coverage, self.ovt_coverage = coverages
@@ -65,8 +62,7 @@ def __init__(
         self.dome_pos = dome_pos
         self.dome_thickness = dome_thickness
 
-    def _create_vertical_target_points(
-            self, anchor, coverage, tilt, radius, length):
+    def _create_vertical_target_points(self, anchor, coverage, tilt, radius, length):
         """Creates a list of points for a vertical target
 
         Args:
@@ -123,29 +119,21 @@ def _create_dome_points(
         points = []
 
         dome_base = extend(
-            c_coord,
-            F,
-            dome_pos *
-            distance_between_two_points(
-                F,
-                c_coord))
+            c_coord, F, dome_pos * distance_between_two_points(F, c_coord)
+        )
         dome_lower_point = extend(
             dome_base, rotate(dome_base, c_coord, -math.pi / 2), dome_height
         )
 
-        D_prime = extend(
-            dome_base,
-            dome_lower_point,
-            dome_height +
-            dome_thickness)
+        d_prime = extend(dome_base, dome_lower_point, dome_height + dome_thickness)
         D = extend(
             dome_lower_point,
-            rotate(dome_lower_point, D_prime, math.pi / 2),
+            rotate(dome_lower_point, d_prime, math.pi / 2),
             dome_length / 2,
         )
         E = extend(
             dome_lower_point,
-            rotate(dome_lower_point, D_prime, -math.pi / 2),
+            rotate(dome_lower_point, d_prime, -math.pi / 2),
             dome_length / 2,
         )
 
@@ -153,7 +141,7 @@ def _create_dome_points(
         points.append([D[0], D[1], "circle"])
 
         # D'
-        points.append([D_prime[0], D_prime[1], "circle"])
+        points.append([d_prime[0], d_prime[1], "circle"])
 
         # E
         points.append([E[0], E[1], "straight"])
@@ -222,8 +210,7 @@ def find_points(self):
         for i, connection in enumerate(connections):
             ovt_points[i].append(connection)
         # ovt_points need to be fliped for correct connections
-        ovt_points = [[float(e[0]), float(e[1]), e[2]]
-                      for e in np.flipud(ovt_points)]
+        ovt_points = [[float(e[0]), float(e[1]), e[2]] for e in np.flipud(ovt_points)]
 
         # Dome points
         dome_points = []
diff --git a/paramak/parametric_components/divertor_ITER_no_dome.py b/paramak/parametric_components/divertor_ITER_no_dome.py
index 77d45f884..6311db253 100644
--- a/paramak/parametric_components/divertor_ITER_no_dome.py
+++ b/paramak/parametric_components/divertor_ITER_no_dome.py
@@ -1,15 +1,10 @@
-
 from paramak import ITERtypeDivertor
 
 
 class ITERtypeDivertorNoDome(ITERtypeDivertor):
-    """Creates an ITER-like divertor with inner and outer vertical targets
-    """
+    """Creates an ITER-like divertor with inner and outer vertical targets"""
 
-    def __init__(
-        self,
-        **kwargs
-    ):
+    def __init__(self, **kwargs):
 
         super().__init__(
             dome=False,
diff --git a/paramak/parametric_components/extrude_rectangle.py b/paramak/parametric_components/extrude_rectangle.py
index 50c60a9f1..fb463b556 100644
--- a/paramak/parametric_components/extrude_rectangle.py
+++ b/paramak/parametric_components/extrude_rectangle.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import ExtrudeStraightShape
 
 
@@ -22,10 +22,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.center_point = center_point
         self.height = height
@@ -75,7 +72,7 @@ def find_points(self):
             (
                 self.center_point[0] - self.width / 2.0,
                 self.center_point[1] + self.height / 2.0,
-            )
+            ),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/hexagon_pin.py b/paramak/parametric_components/hexagon_pin.py
index 72a213822..3b5dbf94d 100644
--- a/paramak/parametric_components/hexagon_pin.py
+++ b/paramak/parametric_components/hexagon_pin.py
@@ -1,4 +1,3 @@
-
 import math
 from typing import Optional, Tuple
 
@@ -24,11 +23,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            distance=distance,
-            **kwargs
-        )
+        super().__init__(name=name, distance=distance, **kwargs)
 
         self.center_point = center_point
         self.length_of_side = length_of_side
@@ -66,10 +61,10 @@ def find_points(self):
 
         points = []
         for i in range(6):
-            point = (self.length_of_side * math.cos(math.pi / 3 * i) +
-                     self.center_point[0],
-                     self.length_of_side * math.sin(math.pi / 3 * i) +
-                     self.center_point[1])
+            point = (
+                self.length_of_side * math.cos(math.pi / 3 * i) + self.center_point[0],
+                self.length_of_side * math.sin(math.pi / 3 * i) + self.center_point[1],
+            )
             points.append(point)
 
         self.points = points
diff --git a/paramak/parametric_components/hollow_cube.py b/paramak/parametric_components/hollow_cube.py
index 388071618..02f5d1e12 100644
--- a/paramak/parametric_components/hollow_cube.py
+++ b/paramak/parametric_components/hollow_cube.py
@@ -1,5 +1,5 @@
-
 import cadquery as cq
+
 from paramak import Shape
 
 
@@ -13,17 +13,10 @@ class HollowCube(Shape):
         thickness (float, optional): thickness of the vessel. Defaults to 10.0.
     """
 
-    def __init__(
-        self,
-        length,
-        thickness=10.,
-        **kwargs
-    ):
+    def __init__(self, length, thickness=10.0, **kwargs):
         self.length = length
         self.thickness = thickness
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
     @property
     def thickness(self):
@@ -44,17 +37,13 @@ def length(self, value):
     def create_solid(self):
 
         # creates a small box that surrounds the geometry
-        inner_box = cq.Workplane("front").box(
-            self.length,
-            self.length,
-            self.length
-        )
+        inner_box = cq.Workplane("front").box(self.length, self.length, self.length)
 
         # creates a large box that surrounds the smaller box
         outer_box = cq.Workplane("front").box(
             self.length + self.thickness,
             self.length + self.thickness,
-            self.length + self.thickness
+            self.length + self.thickness,
         )
 
         # subtracts the two boxes to leave a hollow box
diff --git a/paramak/parametric_components/inboard_firstwall_fccs.py b/paramak/parametric_components/inboard_firstwall_fccs.py
index 81c6076ed..ab4dbd849 100644
--- a/paramak/parametric_components/inboard_firstwall_fccs.py
+++ b/paramak/parametric_components/inboard_firstwall_fccs.py
@@ -1,13 +1,16 @@
-
 from collections.abc import Iterable
 from typing import List, Optional, Tuple
 
-from paramak import (CenterColumnShieldCircular, CenterColumnShieldCylinder,
-                     CenterColumnShieldFlatTopCircular,
-                     CenterColumnShieldFlatTopHyperbola,
-                     CenterColumnShieldHyperbola,
-                     CenterColumnShieldPlasmaHyperbola, RotateMixedShape)
 import paramak
+from paramak import (
+    CenterColumnShieldCircular,
+    CenterColumnShieldCylinder,
+    CenterColumnShieldFlatTopCircular,
+    CenterColumnShieldFlatTopHyperbola,
+    CenterColumnShieldHyperbola,
+    CenterColumnShieldPlasmaHyperbola,
+    RotateMixedShape,
+)
 
 
 class InboardFirstwallFCCS(RotateMixedShape):
@@ -30,10 +33,7 @@ def __init__(
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            **kwargs
-        )
+        super().__init__(color=color, **kwargs)
 
         self.central_column_shield = central_column_shield
         self.thickness = thickness
@@ -63,7 +63,7 @@ def find_points(self):
             CenterColumnShieldFlatTopHyperbola,
             CenterColumnShieldPlasmaHyperbola,
             CenterColumnShieldCircular,
-            CenterColumnShieldFlatTopCircular
+            CenterColumnShieldFlatTopCircular,
         )
         if not isinstance(self.central_column_shield, acceptable_classes):
             raise ValueError(
@@ -72,7 +72,8 @@ def find_points(self):
                 CenterColumnShieldHyperbola, \
                 CenterColumnShieldFlatTopHyperbola, \
                 CenterColumnShieldPlasmaHyperbola, \
-                CenterColumnShieldCircular, CenterColumnShieldFlatTopCircular")
+                CenterColumnShieldCircular, CenterColumnShieldFlatTopCircular"
+            )
 
         inner_radius = self.central_column_shield.inner_radius
         height = self.central_column_shield.height
@@ -81,65 +82,49 @@ def find_points(self):
             firstwall = CenterColumnShieldCylinder(
                 height=height,
                 inner_radius=inner_radius,
-                outer_radius=self.central_column_shield.outer_radius +
-                self.thickness
+                outer_radius=self.central_column_shield.outer_radius + self.thickness,
             )
 
-        elif isinstance(self.central_column_shield,
-                        CenterColumnShieldHyperbola):
+        elif isinstance(self.central_column_shield, CenterColumnShieldHyperbola):
             firstwall = CenterColumnShieldHyperbola(
                 height=height,
                 inner_radius=inner_radius,
-                mid_radius=self.central_column_shield.mid_radius +
-                self.thickness,
-                outer_radius=self.central_column_shield.outer_radius +
-                self.thickness,
+                mid_radius=self.central_column_shield.mid_radius + self.thickness,
+                outer_radius=self.central_column_shield.outer_radius + self.thickness,
             )
 
-        elif isinstance(self.central_column_shield,
-                        CenterColumnShieldFlatTopHyperbola):
+        elif isinstance(self.central_column_shield, CenterColumnShieldFlatTopHyperbola):
             firstwall = CenterColumnShieldFlatTopHyperbola(
                 height=height,
                 arc_height=self.central_column_shield.arc_height,
                 inner_radius=inner_radius,
-                mid_radius=self.central_column_shield.mid_radius +
-                self.thickness,
-                outer_radius=self.central_column_shield.outer_radius +
-                self.thickness,
+                mid_radius=self.central_column_shield.mid_radius + self.thickness,
+                outer_radius=self.central_column_shield.outer_radius + self.thickness,
             )
 
-        elif isinstance(self.central_column_shield,
-                        CenterColumnShieldPlasmaHyperbola):
+        elif isinstance(self.central_column_shield, CenterColumnShieldPlasmaHyperbola):
             firstwall = CenterColumnShieldPlasmaHyperbola(
                 height=height,
                 inner_radius=inner_radius,
-                mid_offset=self.central_column_shield.mid_offset -
-                self.thickness,
-                edge_offset=self.central_column_shield.edge_offset -
-                self.thickness,
+                mid_offset=self.central_column_shield.mid_offset - self.thickness,
+                edge_offset=self.central_column_shield.edge_offset - self.thickness,
             )
 
-        elif isinstance(self.central_column_shield,
-                        CenterColumnShieldCircular):
+        elif isinstance(self.central_column_shield, CenterColumnShieldCircular):
             firstwall = CenterColumnShieldCircular(
                 height=height,
                 inner_radius=inner_radius,
-                mid_radius=self.central_column_shield.mid_radius +
-                self.thickness,
-                outer_radius=self.central_column_shield.outer_radius +
-                self.thickness,
+                mid_radius=self.central_column_shield.mid_radius + self.thickness,
+                outer_radius=self.central_column_shield.outer_radius + self.thickness,
             )
 
-        elif isinstance(self.central_column_shield,
-                        CenterColumnShieldFlatTopCircular):
+        elif isinstance(self.central_column_shield, CenterColumnShieldFlatTopCircular):
             firstwall = CenterColumnShieldFlatTopCircular(
                 height=height,
                 arc_height=self.central_column_shield.arc_height,
                 inner_radius=inner_radius,
-                mid_radius=self.central_column_shield.mid_radius +
-                self.thickness,
-                outer_radius=self.central_column_shield.outer_radius +
-                self.thickness,
+                mid_radius=self.central_column_shield.mid_radius + self.thickness,
+                outer_radius=self.central_column_shield.outer_radius + self.thickness,
             )
 
         firstwall.rotation_angle = self.rotation_angle
diff --git a/paramak/parametric_components/inner_tf_coils_circular.py b/paramak/parametric_components/inner_tf_coils_circular.py
index 2ad73b028..af0d69ecd 100644
--- a/paramak/parametric_components/inner_tf_coils_circular.py
+++ b/paramak/parametric_components/inner_tf_coils_circular.py
@@ -1,7 +1,8 @@
-
 import math
 from typing import Optional
+
 import numpy as np
+
 from paramak import ExtrudeMixedShape
 
 
@@ -34,10 +35,7 @@ def __init__(
     ) -> None:
 
         super().__init__(
-            distance=height,
-            workplane=workplane,
-            rotation_axis=rotation_axis,
-            **kwargs
+            distance=height, workplane=workplane, rotation_axis=rotation_axis, **kwargs
         )
 
         self.azimuth_start_angle = azimuth_start_angle
@@ -117,7 +115,7 @@ def find_points(self):
         """Finds the points that describe the 2D profile of the tf coil shape"""
 
         if self.gap_size * self.number_of_coils > 2 * math.pi * self.inner_radius:
-            raise ValueError('gap_size is too large')
+            raise ValueError("gap_size is too large")
 
         theta_inner = (
             (2 * math.pi * self.inner_radius) - (self.gap_size * self.number_of_coils)
@@ -201,6 +199,8 @@ def find_azimuth_placement_angle(self):
                 0 + self.azimuth_start_angle,
                 360 + self.azimuth_start_angle,
                 self.number_of_coils,
-                endpoint=False))
+                endpoint=False,
+            )
+        )
 
         self.azimuth_placement_angle = angles
diff --git a/paramak/parametric_components/inner_tf_coils_flat.py b/paramak/parametric_components/inner_tf_coils_flat.py
index 06b45d342..d15f359ae 100644
--- a/paramak/parametric_components/inner_tf_coils_flat.py
+++ b/paramak/parametric_components/inner_tf_coils_flat.py
@@ -1,7 +1,8 @@
-
 import math
 from typing import Optional
+
 import numpy as np
+
 from paramak import ExtrudeStraightShape
 
 
@@ -34,18 +35,15 @@ def __init__(
         outer_radius: float,
         number_of_coils: int,
         gap_size: float,
-        radius_type: Optional[str] = 'corner',
+        radius_type: Optional[str] = "corner",
         azimuth_start_angle: Optional[float] = 0.0,
         workplane: Optional[str] = "XY",
         rotation_axis: Optional[str] = "Z",
-        **kwargs
+        **kwargs,
     ) -> None:
 
         super().__init__(
-            distance=height,
-            workplane=workplane,
-            rotation_axis=rotation_axis,
-            **kwargs
+            distance=height, workplane=workplane, rotation_axis=rotation_axis, **kwargs
         )
 
         self.azimuth_start_angle = azimuth_start_angle
@@ -71,9 +69,8 @@ def radius_type(self):
 
     @radius_type.setter
     def radius_type(self, value):
-        if value not in ['corner', 'straight']:
-            msg = (
-                f'radius_type must be either "corner" or "straight". Not {value}')
+        if value not in ["corner", "straight"]:
+            msg = f'radius_type must be either "corner" or "straight". Not {value}'
             raise ValueError(msg)
         self._radius_type = value
 
@@ -152,31 +149,33 @@ def find_points(self):
         #     \    \ ¦
         #      \    p3
 
-        if self.radius_type == 'corner':
+        if self.radius_type == "corner":
             distance_to_inner_corner = self.inner_radius
             distance_to_rear_corner = self.outer_radius
         # this section calculates a new distance to the corners now that we
         # know the user provided the distance to the straight
-        if self.radius_type == 'straight':
+        if self.radius_type == "straight":
             angle = 360 / (self.number_of_coils * 2)
-            distance_to_inner_corner = self.inner_radius / \
-                math.cos(math.radians(angle))
-            distance_to_rear_corner = self.outer_radius / \
-                math.cos(math.radians(angle))
+            distance_to_inner_corner = self.inner_radius / math.cos(math.radians(angle))
+            distance_to_rear_corner = self.outer_radius / math.cos(math.radians(angle))
 
-        if self.gap_size * self.number_of_coils > 2 * math.pi * distance_to_inner_corner:
+        if (
+            self.gap_size * self.number_of_coils
+            > 2 * math.pi * distance_to_inner_corner
+        ):
             msg = (
-                'Gap_size is too large. The gap_size * number of coils must '
-                'be less than the circumference of the circle made by '
-                'the inner_radius')
+                "Gap_size is too large. The gap_size * number of coils must "
+                "be less than the circumference of the circle made by "
+                "the inner_radius"
+            )
             raise ValueError(msg)
 
-        if distance_to_inner_corner != 0.:
+        if distance_to_inner_corner != 0.0:
             theta_inner = (
-                (2 * math.pi * distance_to_inner_corner) - (self.gap_size * self.number_of_coils)
+                (2 * math.pi * distance_to_inner_corner)
+                - (self.gap_size * self.number_of_coils)
             ) / (distance_to_inner_corner * self.number_of_coils)
-            omega_inner = math.asin(
-                self.gap_size / (2 * distance_to_inner_corner))
+            omega_inner = math.asin(self.gap_size / (2 * distance_to_inner_corner))
 
             # inner points
             point_1 = (
@@ -185,18 +184,23 @@ def find_points(self):
             )
             point_2 = (
                 (
-                    distance_to_inner_corner * math.cos(theta_inner) * math.cos(-omega_inner)
-                    + distance_to_inner_corner * math.sin(theta_inner) * math.sin(-omega_inner)
+                    distance_to_inner_corner
+                    * math.cos(theta_inner)
+                    * math.cos(-omega_inner)
+                    + distance_to_inner_corner
+                    * math.sin(theta_inner)
+                    * math.sin(-omega_inner)
                 ),
                 (
-                    -distance_to_inner_corner * math.cos(theta_inner) * math.sin(-omega_inner)
-                    + distance_to_inner_corner * math.sin(theta_inner) * math.cos(-omega_inner)
+                    -distance_to_inner_corner
+                    * math.cos(theta_inner)
+                    * math.sin(-omega_inner)
+                    + distance_to_inner_corner
+                    * math.sin(theta_inner)
+                    * math.cos(-omega_inner)
                 ),
             )
-            points = [
-                (point_1[0], point_1[1]),
-                (point_2[0], point_2[1])
-            ]
+            points = [(point_1[0], point_1[1]), (point_2[0], point_2[1])]
 
         else:
 
@@ -206,7 +210,8 @@ def find_points(self):
         # print(point_2)
 
         theta_outer = (
-            (2 * math.pi * distance_to_rear_corner) - (self.gap_size * self.number_of_coils)
+            (2 * math.pi * distance_to_rear_corner)
+            - (self.gap_size * self.number_of_coils)
         ) / (distance_to_rear_corner * self.number_of_coils)
         omega_outer = math.asin(self.gap_size / (2 * distance_to_rear_corner))
 
@@ -218,11 +223,17 @@ def find_points(self):
         point_6 = (
             (
                 distance_to_rear_corner * math.cos(theta_outer) * math.cos(-omega_outer)
-                + distance_to_rear_corner * math.sin(theta_outer) * math.sin(-omega_outer)
+                + distance_to_rear_corner
+                * math.sin(theta_outer)
+                * math.sin(-omega_outer)
             ),
             (
-                -distance_to_rear_corner * math.cos(theta_outer) * math.sin(-omega_outer)
-                + distance_to_rear_corner * math.sin(theta_outer) * math.cos(-omega_outer)
+                -distance_to_rear_corner
+                * math.cos(theta_outer)
+                * math.sin(-omega_outer)
+                + distance_to_rear_corner
+                * math.sin(theta_outer)
+                * math.cos(-omega_outer)
             ),
         )
         points.append((point_6[0], point_6[1]))
@@ -239,6 +250,8 @@ def find_azimuth_placement_angle(self):
                 0 + self.azimuth_start_angle,
                 360 + self.azimuth_start_angle,
                 self.number_of_coils,
-                endpoint=False))
+                endpoint=False,
+            )
+        )
 
         self.azimuth_placement_angle = angles
diff --git a/paramak/parametric_components/poloidal_field_coil.py b/paramak/parametric_components/poloidal_field_coil.py
index d207ca64a..94f4052d6 100644
--- a/paramak/parametric_components/poloidal_field_coil.py
+++ b/paramak/parametric_components/poloidal_field_coil.py
@@ -1,5 +1,5 @@
-
 from typing import Optional, Tuple
+
 from paramak import RotateStraightShape
 
 
@@ -22,10 +22,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.center_point = center_point
         self.height = height
@@ -75,7 +72,7 @@ def find_points(self):
             (
                 self.center_point[0] - self.width / 2.0,
                 self.center_point[1] + self.height / 2.0,
-            )
+            ),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/poloidal_field_coil_case.py b/paramak/parametric_components/poloidal_field_coil_case.py
index 9ee4ebb15..37087b0cb 100644
--- a/paramak/parametric_components/poloidal_field_coil_case.py
+++ b/paramak/parametric_components/poloidal_field_coil_case.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import RotateStraightShape
@@ -21,14 +20,11 @@ def __init__(
         coil_height: float,
         coil_width: float,
         center_point: Tuple[float, float],
-        color: Optional[Tuple[int, int, int]] = (1., 1., 0.498),
+        color: Optional[Tuple[int, int, int]] = (1.0, 1.0, 0.498),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            color=color,
-            **kwargs
-        )
+        super().__init__(color=color, **kwargs)
 
         self.center_point = center_point
         self.height = coil_height
@@ -85,35 +81,25 @@ def find_points(self):
                 self.center_point[1] + self.height / 2.0,
             ),  # upper right
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] - \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] - (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] - \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] - \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] - (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] - (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] - \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] - (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
-            )
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
+            ),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/poloidal_field_coil_case_fc.py b/paramak/parametric_components/poloidal_field_coil_case_fc.py
index 777e6e1b6..bc6f505eb 100644
--- a/paramak/parametric_components/poloidal_field_coil_case_fc.py
+++ b/paramak/parametric_components/poloidal_field_coil_case_fc.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import RotateStraightShape
@@ -18,14 +17,11 @@ def __init__(
         self,
         pf_coil,
         casing_thickness,
-        color: Optional[Tuple[int, int, int]] = (1., 1., 0.498),
+        color: Optional[Tuple[int, int, int]] = (1.0, 1.0, 0.498),
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            **kwargs
-        )
+        super().__init__(color=color, **kwargs)
 
         self.center_point = pf_coil.center_point
         self.height = pf_coil.height
@@ -82,35 +78,25 @@ def find_points(self):
                 self.center_point[1] + self.height / 2.0,
             ),  # upper right
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] - \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] - (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] - \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] - \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] - (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] - (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] - \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
+                self.center_point[0] - (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
             ),
             (
-                self.center_point[0] + \
-                (self.casing_thickness + self.width / 2.0),
-                self.center_point[1] + \
-                (self.casing_thickness + self.height / 2.0),
-            )
+                self.center_point[0] + (self.casing_thickness + self.width / 2.0),
+                self.center_point[1] + (self.casing_thickness + self.height / 2.0),
+            ),
         ]
 
         self.points = points
diff --git a/paramak/parametric_components/poloidal_field_coil_case_set.py b/paramak/parametric_components/poloidal_field_coil_case_set.py
index 5d54d003a..764ad2169 100644
--- a/paramak/parametric_components/poloidal_field_coil_case_set.py
+++ b/paramak/parametric_components/poloidal_field_coil_case_set.py
@@ -1,7 +1,7 @@
-
 from typing import Optional, Tuple
 
 import cadquery as cq
+
 from paramak import RotateStraightShape
 
 
@@ -29,15 +29,11 @@ def __init__(
         casing_thicknesses,
         center_points,
         name="pf_coil_case_set",
-        color: Optional[Tuple[int, int, int]] = (1., 1., 0.498),
+        color: Optional[Tuple[int, int, int]] = (1.0, 1.0, 0.498),
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            color=color,
-            **kwargs
-        )
+        super().__init__(name=name, color=color, **kwargs)
 
         self.center_points = center_points
         self.heights = heights
@@ -77,11 +73,13 @@ def casing_thicknesses(self, value):
         if isinstance(value, list):
             if not all(isinstance(x, (int, float)) for x in value):
                 raise ValueError(
-                    "Every entry in Casing_thicknesses must be a float or int")
+                    "Every entry in Casing_thicknesses must be a float or int"
+                )
         else:
             if not isinstance(value, (float, int)):
                 raise ValueError(
-                    "Casing_thicknesses must be a list of numbers or a number")
+                    "Casing_thicknesses must be a list of numbers or a number"
+                )
         self._casing_thicknesses = value
 
     def find_points(self):
@@ -93,20 +91,22 @@ def find_points(self):
         if isinstance(self.casing_thicknesses, list):
             casing_thicknesses_list = self.casing_thicknesses
         else:
-            casing_thicknesses_list = [
-                self.casing_thicknesses] * len(self.widths)
+            casing_thicknesses_list = [self.casing_thicknesses] * len(self.widths)
 
-        if not len(
-            self.heights) == len(
-            self.widths) == len(
-                self.center_points) == len(casing_thicknesses_list):
+        if (
+            not len(self.heights)
+            == len(self.widths)
+            == len(self.center_points)
+            == len(casing_thicknesses_list)
+        ):
             raise ValueError(
                 "The number of heights, widths, center_points and "
-                "casing_thicknesses must be equal")
+                "casing_thicknesses must be equal"
+            )
 
         for height, width, center_point, casing_thickness in zip(
-                self.heights, self.widths,
-                self.center_points, casing_thicknesses_list):
+            self.heights, self.widths, self.center_points, casing_thicknesses_list
+        ):
 
             if casing_thickness != 0:
 
@@ -150,7 +150,7 @@ def find_points(self):
                     (
                         center_point[0] + (casing_thickness + width / 2.0),
                         center_point[1] + (casing_thickness + height / 2.0),
-                    )
+                    ),
                 ]
 
         self.points = all_points
@@ -158,24 +158,39 @@ def find_points(self):
     def create_solid(self):
         """Creates a 3d solid using points with straight edges.
 
-           Returns:
-              A CadQuery solid: A 3D solid volume
+        Returns:
+           A CadQuery solid: A 3D solid volume
         """
 
         iter_points = iter(self.points)
         pf_coils_set = []
         wires = []
         for p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 in zip(
-                iter_points, iter_points, iter_points, iter_points,
-                iter_points, iter_points, iter_points, iter_points,
-                iter_points, iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
         ):
 
-            solid = (
-                cq.Workplane(self.workplane)
-                .polyline(
-                    [p1[:2], p2[:2], p3[:2], p4[:2], p5[:2], p6[:2],
-                     p7[:2], p8[:2], p9[:2], p10[:2]])
+            solid = cq.Workplane(self.workplane).polyline(
+                [
+                    p1[:2],
+                    p2[:2],
+                    p3[:2],
+                    p4[:2],
+                    p5[:2],
+                    p6[:2],
+                    p7[:2],
+                    p8[:2],
+                    p9[:2],
+                    p10[:2],
+                ]
             )
 
             wire = solid.close()
@@ -186,9 +201,7 @@ def create_solid(self):
 
             pf_coils_set.append(solid)
 
-        compound = cq.Compound.makeCompound(
-            [a.val() for a in pf_coils_set]
-        )
+        compound = cq.Compound.makeCompound([a.val() for a in pf_coils_set])
 
         self.wire = wires
 
diff --git a/paramak/parametric_components/poloidal_field_coil_case_set_fc.py b/paramak/parametric_components/poloidal_field_coil_case_set_fc.py
index 69fb0a317..6ac886518 100644
--- a/paramak/parametric_components/poloidal_field_coil_case_set_fc.py
+++ b/paramak/parametric_components/poloidal_field_coil_case_set_fc.py
@@ -1,7 +1,7 @@
-
 from typing import Optional, Tuple
 
 import cadquery as cq
+
 from paramak import PoloidalFieldCoilSet, RotateStraightShape
 
 
@@ -23,15 +23,11 @@ def __init__(
         pf_coils,
         casing_thicknesses,
         name="pf_coil_case_set_fc",
-        color: Optional[Tuple[int, int, int]] = (1., 1., 0.498),
+        color: Optional[Tuple[int, int, int]] = (1.0, 1.0, 0.498),
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            color=color,
-            **kwargs
-        )
+        super().__init__(name=name, color=color, **kwargs)
 
         self.casing_thicknesses = casing_thicknesses
         self.pf_coils = pf_coils
@@ -50,11 +46,13 @@ def casing_thicknesses(self, value):
         if isinstance(value, list):
             if not all(isinstance(x, (int, float)) for x in value):
                 raise ValueError(
-                    "Every entry in Casing_thicknesses must be a float or int")
+                    "Every entry in Casing_thicknesses must be a float or int"
+                )
         else:
             if not isinstance(value, (float, int)):
                 raise ValueError(
-                    "Casing_thicknesses must be a list of numbers or a number")
+                    "Casing_thicknesses must be a list of numbers or a number"
+                )
         self._casing_thicknesses = value
 
     @property
@@ -64,9 +62,11 @@ def pf_coils(self):
     @pf_coils.setter
     def pf_coils(self, value):
         if not isinstance(value, (list, PoloidalFieldCoilSet)):
-            msg = ('PoloidalFieldCoilCaseSetFC.pf_coils must be either a list '
-                   'paramak.PoloidalFieldCoil or a '
-                   'paramak.PoloidalFieldCoilSet object')
+            msg = (
+                "PoloidalFieldCoilCaseSetFC.pf_coils must be either a list "
+                "paramak.PoloidalFieldCoil or a "
+                "paramak.PoloidalFieldCoilSet object"
+            )
             raise ValueError(msg)
         self._pf_coils = value
 
@@ -77,8 +77,7 @@ def find_points(self):
         if isinstance(self.pf_coils, list):
             self.heights = [entry.height for entry in self.pf_coils]
             self.widths = [entry.width for entry in self.pf_coils]
-            self.center_points = [
-                entry.center_point for entry in self.pf_coils]
+            self.center_points = [entry.center_point for entry in self.pf_coils]
 
             num_of_coils = len(self.pf_coils)
 
@@ -96,7 +95,8 @@ def find_points(self):
                     "casing_thicknesses=",
                     self.casing_thicknesses,
                     "num_of_coils=",
-                    num_of_coils)
+                    num_of_coils,
+                )
             casing_thicknesses_list = self.casing_thicknesses
         else:
             casing_thicknesses_list = [self.casing_thicknesses] * num_of_coils
@@ -104,8 +104,8 @@ def find_points(self):
         all_points = []
 
         for height, width, center_point, casing_thickness in zip(
-                self.heights, self.widths,
-                self.center_points, casing_thicknesses_list):
+            self.heights, self.widths, self.center_points, casing_thicknesses_list
+        ):
 
             if casing_thickness != 0:
 
@@ -149,7 +149,7 @@ def find_points(self):
                     (
                         center_point[0] + (casing_thickness + width / 2.0),
                         center_point[1] + (casing_thickness + height / 2.0),
-                    )
+                    ),
                 ]
 
         self.points = all_points
@@ -167,16 +167,31 @@ def create_solid(self):
         pf_coils_set = []
         wires = []
         for p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 in zip(
-                iter_points, iter_points, iter_points, iter_points,
-                iter_points, iter_points, iter_points, iter_points,
-                iter_points, iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
+            iter_points,
         ):
 
-            solid = (
-                cq.Workplane(self.workplane)
-                .polyline(
-                    [p1[:2], p2[:2], p3[:2], p4[:2], p5[:2], p6[:2],
-                     p7[:2], p8[:2], p9[:2], p10[:2]])
+            solid = cq.Workplane(self.workplane).polyline(
+                [
+                    p1[:2],
+                    p2[:2],
+                    p3[:2],
+                    p4[:2],
+                    p5[:2],
+                    p6[:2],
+                    p7[:2],
+                    p8[:2],
+                    p9[:2],
+                    p10[:2],
+                ]
             )
 
             wire = solid.close()
@@ -187,9 +202,7 @@ def create_solid(self):
 
             pf_coils_set.append(solid)
 
-        compound = cq.Compound.makeCompound(
-            [a.val() for a in pf_coils_set]
-        )
+        compound = cq.Compound.makeCompound([a.val() for a in pf_coils_set])
 
         self.wire = wires
 
diff --git a/paramak/parametric_components/poloidal_field_coil_fp.py b/paramak/parametric_components/poloidal_field_coil_fp.py
index 83b0024c9..bc1b21849 100644
--- a/paramak/parametric_components/poloidal_field_coil_fp.py
+++ b/paramak/parametric_components/poloidal_field_coil_fp.py
@@ -1,4 +1,3 @@
-
 from paramak import PoloidalFieldCoil
 
 
@@ -10,24 +9,17 @@ class PoloidalFieldCoilFP(PoloidalFieldCoil):
             corners of the rectangular shaped coil e.g [(x1, y1), (x2, y2)]
     """
 
-    def __init__(
-        self,
-        corner_points,
-        **kwargs
-    ):
+    def __init__(self, corner_points, **kwargs):
 
         height = abs(corner_points[0][1] - corner_points[1][1])
         width = abs(corner_points[0][0] - corner_points[1][0])
 
-        center_width = (corner_points[0][1] + corner_points[1][1]) / 2.
-        center_height = (corner_points[0][1] + corner_points[1][1]) / 2.
+        center_width = (corner_points[0][1] + corner_points[1][1]) / 2.0
+        center_height = (corner_points[0][1] + corner_points[1][1]) / 2.0
         center_point = (center_width, center_height)
 
         super().__init__(
-            height=height,
-            width=width,
-            center_point=center_point,
-            **kwargs
+            height=height, width=width, center_point=center_point, **kwargs
         )
 
         self.corner_points = corner_points
diff --git a/paramak/parametric_components/poloidal_field_coil_set.py b/paramak/parametric_components/poloidal_field_coil_set.py
index 4d35796a3..b1a53762a 100644
--- a/paramak/parametric_components/poloidal_field_coil_set.py
+++ b/paramak/parametric_components/poloidal_field_coil_set.py
@@ -1,5 +1,5 @@
-
 import cadquery as cq
+
 from paramak import RotateStraightShape
 
 
@@ -16,31 +16,21 @@ class PoloidalFieldCoilSet(RotateStraightShape):
         name (str, optional): defaults to "pf_coil".
     """
 
-    def __init__(
-        self,
-        heights,
-        widths,
-        center_points,
-        name="pf_coil",
-        **kwargs
-    ):
+    def __init__(self, heights, widths, center_points, name="pf_coil", **kwargs):
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.center_points = center_points
         self.heights = heights
         self.widths = widths
 
-        if len(
-            self.widths) != len(
-            self.heights) or len(
-            self.heights) != len(
-                self.center_points):
-            raise ValueError("The length of widthts, height and center_points \
-                must be the same when making a PoloidalFieldCoilSet")
+        if len(self.widths) != len(self.heights) or len(self.heights) != len(
+            self.center_points
+        ):
+            raise ValueError(
+                "The length of widthts, height and center_points \
+                must be the same when making a PoloidalFieldCoilSet"
+            )
 
     @property
     def center_points(self):
@@ -49,8 +39,7 @@ def center_points(self):
     @center_points.setter
     def center_points(self, value):
         if not isinstance(value, list):
-            raise ValueError(
-                "PoloidalFieldCoilSet center_points must be a list")
+            raise ValueError("PoloidalFieldCoilSet center_points must be a list")
         self._center_points = value
 
     @property
@@ -80,7 +69,8 @@ def find_points(self):
         all_points = []
 
         for height, width, center_point in zip(
-                self.heights, self.widths, self.center_points):
+            self.heights, self.widths, self.center_points
+        ):
 
             all_points = all_points + [
                 (
@@ -116,12 +106,10 @@ def create_solid(self):
         iter_points = iter(self.points)
         pf_coils_set = []
         wires = []
-        for p1, p2, p3, p4 in zip(
-                iter_points, iter_points, iter_points, iter_points):
+        for point_1, point_2, point_3, point_4 in zip(iter_points, iter_points, iter_points, iter_points):
 
-            solid = (
-                cq.Workplane(self.workplane)
-                .polyline([p1[:2], p2[:2], p3[:2], p4[:2]])
+            solid = cq.Workplane(self.workplane).polyline(
+                [point_1[:2], point_2[:2], point_3[:2], point_4[:2]]
             )
 
             wire = solid.close()
@@ -132,9 +120,7 @@ def create_solid(self):
 
             pf_coils_set.append(solid)
 
-        compound = cq.Compound.makeCompound(
-            [a.val() for a in pf_coils_set]
-        )
+        compound = cq.Compound.makeCompound([a.val() for a in pf_coils_set])
 
         self.wire = wires
 
diff --git a/paramak/parametric_components/poloidal_segmenter.py b/paramak/parametric_components/poloidal_segmenter.py
index 85006a891..ec5607fee 100644
--- a/paramak/parametric_components/poloidal_segmenter.py
+++ b/paramak/parametric_components/poloidal_segmenter.py
@@ -1,10 +1,9 @@
-
 import math
 
 import cadquery as cq
+
 from paramak import RotateStraightShape
-from paramak.utils import (coefficients_of_line_from_points, intersect_solid,
-                           rotate)
+from paramak.utils import coefficients_of_line_from_points, intersect_solid, rotate
 
 
 class PoloidalSegments(RotateStraightShape):
@@ -35,10 +34,7 @@ def __init__(
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.center_point = center_point
         self.shape_to_segment = shape_to_segment
@@ -52,11 +48,11 @@ def number_of_segments(self):
     @number_of_segments.setter
     def number_of_segments(self, value):
         if isinstance(value, int) is False:
-            raise TypeError(
-                "PoloidalSegmenter.number_of_segments must be an int.")
+            raise TypeError("PoloidalSegmenter.number_of_segments must be an int.")
         if value < 1:
             raise ValueError(
-                "PoloidalSegmenter.number_of_segments must be a minimum of 1.")
+                "PoloidalSegmenter.number_of_segments must be a minimum of 1."
+            )
         self._number_of_segments = value
 
     @property
@@ -87,37 +83,36 @@ def find_points(self):
         """Finds the XZ points joined by straight connections that describe
         the 2D profile of the poloidal segmentation shape."""
 
-        angle_per_segment = 360. / self.number_of_segments
+        angle_per_segment = 360.0 / self.number_of_segments
 
         points = []
 
         current_angle = 0
 
         outer_point = (
-            self.center_point[0] +
-            self.max_distance_from_center,
-            self.center_point[1])
+            self.center_point[0] + self.max_distance_from_center,
+            self.center_point[1],
+        )
         for i in range(self.number_of_segments):
 
             points.append(self.center_point)
 
             outer_point_1 = rotate(
-                self.center_point,
-                outer_point,
-                math.radians(current_angle)
+                self.center_point, outer_point, math.radians(current_angle)
             )
 
             outer_point_2 = rotate(
                 self.center_point,
                 outer_point,
-                math.radians(current_angle + angle_per_segment)
+                math.radians(current_angle + angle_per_segment),
             )
 
             # if the point goes beyond the zero line then set to zero
             for new_point in [outer_point_1, outer_point_2]:
                 if new_point[0] < 0:
                     m, c = coefficients_of_line_from_points(
-                        new_point, self.center_point)
+                        new_point, self.center_point
+                    )
                     points.append((0, c))
                 else:
                     points.append(new_point)
@@ -140,10 +135,7 @@ def create_solid(self):
         wires = []
         for p1, p2, p3 in zip(iter_points, iter_points, iter_points):
 
-            solid = (
-                cq.Workplane(self.workplane)
-                .polyline([p1[:2], p2[:2], p3[:2]])
-            )
+            solid = cq.Workplane(self.workplane).polyline([p1[:2], p2[:2], p3[:2]])
 
             wire = solid.close()
 
@@ -157,9 +149,7 @@ def create_solid(self):
 
         if self.shape_to_segment is None:
 
-            compound = cq.Compound.makeCompound(
-                [a.val() for a in triangle_wedges]
-            )
+            compound = cq.Compound.makeCompound([a.val() for a in triangle_wedges])
 
         else:
 
@@ -168,9 +158,7 @@ def create_solid(self):
                 overlap = intersect_solid(segment, self.shape_to_segment)
                 intersected_solids.append(overlap)
 
-            compound = cq.Compound.makeCompound(
-                [a.val() for a in intersected_solids]
-            )
+            compound = cq.Compound.makeCompound([a.val() for a in intersected_solids])
 
         self.solid = compound
 
diff --git a/paramak/parametric_components/port_cutters_circular.py b/paramak/parametric_components/port_cutters_circular.py
index c36969c6e..c34e385f1 100644
--- a/paramak/parametric_components/port_cutters_circular.py
+++ b/paramak/parametric_components/port_cutters_circular.py
@@ -1,4 +1,3 @@
-
 from typing import Optional
 
 from paramak import ExtrudeCircleShape
@@ -28,7 +27,7 @@ def __init__(
         center_point: Optional[tuple] = (0, 0),
         workplane: Optional[str] = "ZY",
         rotation_axis: Optional[str] = "Z",
-        extrusion_start_offset: Optional[float] = 1.,
+        extrusion_start_offset: Optional[float] = 1.0,
         name: Optional[str] = "circular_port_cutter",
         **kwargs
     ):
diff --git a/paramak/parametric_components/port_cutters_rectangular.py b/paramak/parametric_components/port_cutters_rectangular.py
index 2aa3848ce..9c277dd9a 100644
--- a/paramak/parametric_components/port_cutters_rectangular.py
+++ b/paramak/parametric_components/port_cutters_rectangular.py
@@ -1,4 +1,3 @@
-
 from typing import Optional
 
 from paramak import ExtrudeStraightShape
@@ -32,7 +31,7 @@ def __init__(
         center_point: Optional[tuple] = (0, 0),
         workplane: Optional[str] = "ZY",
         rotation_axis: Optional[str] = "Z",
-        extrusion_start_offset: Optional[float] = 1.,
+        extrusion_start_offset: Optional[float] = 1.0,
         fillet_radius: Optional[float] = None,
         name: Optional[str] = "rectangular_port_cutter",
         **kwargs
@@ -67,8 +66,9 @@ def find_points(self):
             (parameter_1 / 2, -parameter_2 / 2),
             (-parameter_1 / 2, -parameter_2 / 2),
         ]
-        points = [(e[0] + self.center_point[0], e[1] +
-                   self.center_point[1]) for e in points]
+        points = [
+            (e[0] + self.center_point[0], e[1] + self.center_point[1]) for e in points
+        ]
 
         self.points = points
 
diff --git a/paramak/parametric_components/port_cutters_rotated.py b/paramak/parametric_components/port_cutters_rotated.py
index db15406ee..7495d5390 100644
--- a/paramak/parametric_components/port_cutters_rotated.py
+++ b/paramak/parametric_components/port_cutters_rotated.py
@@ -1,4 +1,3 @@
-
 import math
 
 from paramak import RotateStraightShape
@@ -38,11 +37,7 @@ def __init__(
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            rotation_angle=rotation_angle,
-            **kwargs
-        )
+        super().__init__(name=name, rotation_angle=rotation_angle, **kwargs)
 
         self.center_point = center_point
         self.polar_coverage_angle = polar_coverage_angle
@@ -85,23 +80,26 @@ def find_points(self):
 
         points = [self.center_point]
 
-        outer_point = (self.center_point[0] + self.max_distance_from_center,
-                       self.center_point[1])
+        outer_point = (
+            self.center_point[0] + self.max_distance_from_center,
+            self.center_point[1],
+        )
 
         outer_point_rotated = rotate(
-            self.center_point,
-            outer_point,
-            math.radians(self.polar_placement_angle))
+            self.center_point, outer_point, math.radians(self.polar_placement_angle)
+        )
 
         outer_point_1 = rotate(
             self.center_point,
             outer_point_rotated,
-            math.radians(0.5 * self.polar_coverage_angle))
+            math.radians(0.5 * self.polar_coverage_angle),
+        )
 
         outer_point_2 = rotate(
             self.center_point,
             outer_point_rotated,
-            math.radians(-0.5 * self.polar_coverage_angle))
+            math.radians(-0.5 * self.polar_coverage_angle),
+        )
 
         points.append(outer_point_1)
         points.append(outer_point_2)
diff --git a/paramak/parametric_components/rotated_isosceles_triangle.py b/paramak/parametric_components/rotated_isosceles_triangle.py
index 5c6c39a5a..2c0e7e296 100644
--- a/paramak/parametric_components/rotated_isosceles_triangle.py
+++ b/paramak/parametric_components/rotated_isosceles_triangle.py
@@ -1,4 +1,3 @@
-
 import math
 
 from paramak import RotateStraightShape
@@ -23,15 +22,12 @@ def __init__(
         base_length,
         height,
         pivot_point,
-        pivot_angle=0.,
+        pivot_angle=0.0,
         name="rotated_triangle",
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.base_length = base_length
         self.height = height
@@ -78,11 +74,11 @@ def find_points(self):
             self.pivot_point,
             (
                 self.pivot_point[0] - self.base_length / 2.0,
-                self.pivot_point[1] - self.height
+                self.pivot_point[1] - self.height,
             ),
             (
                 self.pivot_point[0] + self.base_length / 2.0,
-                self.pivot_point[1] - self.height
+                self.pivot_point[1] - self.height,
             ),
         ]
 
@@ -92,7 +88,7 @@ def find_points(self):
             x, y = rotate(
                 origin=self.pivot_point,
                 point=point,
-                angle=math.radians(self.pivot_angle)
+                angle=math.radians(self.pivot_angle),
             )
             points.append((x, y))
 
diff --git a/paramak/parametric_components/rotated_trapezoid.py b/paramak/parametric_components/rotated_trapezoid.py
index a06dda3b1..5a48e33b9 100644
--- a/paramak/parametric_components/rotated_trapezoid.py
+++ b/paramak/parametric_components/rotated_trapezoid.py
@@ -1,4 +1,3 @@
-
 import math
 
 from paramak import RotateStraightShape
@@ -29,15 +28,12 @@ def __init__(
         length_2,
         length_3,
         pivot_point,
-        pivot_angle=0.,
+        pivot_angle=0.0,
         name="rotated_trapezoid",
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         self.length_1 = length_1
         self.length_2 = length_2
@@ -90,21 +86,15 @@ def find_points(self):
         the 2D profile of the trapezoid shape."""
 
         non_rotated_points = [
-            (
-                self.pivot_point[0] + self.length_1 / 2.0,
-                self.pivot_point[1]
-            ),
-            (
-                self.pivot_point[0] - self.length_1 / 2.0,
-                self.pivot_point[1]
-            ),
+            (self.pivot_point[0] + self.length_1 / 2.0, self.pivot_point[1]),
+            (self.pivot_point[0] - self.length_1 / 2.0, self.pivot_point[1]),
             (
                 self.pivot_point[0] - self.length_2 / 2.0,
-                self.pivot_point[1] - self.length_3
+                self.pivot_point[1] - self.length_3,
             ),
             (
                 self.pivot_point[0] + self.length_2 / 2.0,
-                self.pivot_point[1] - self.length_3
+                self.pivot_point[1] - self.length_3,
             ),
         ]
 
@@ -114,7 +104,7 @@ def find_points(self):
             x, y = rotate(
                 origin=self.pivot_point,
                 point=point,
-                angle=math.radians(self.pivot_angle)
+                angle=math.radians(self.pivot_angle),
             )
             points.append((x, y))
 
diff --git a/paramak/parametric_components/shell_fs.py b/paramak/parametric_components/shell_fs.py
index f580fe9e8..ff3e11392 100644
--- a/paramak/parametric_components/shell_fs.py
+++ b/paramak/parametric_components/shell_fs.py
@@ -1,5 +1,5 @@
-
 import cadquery as cq
+
 from paramak import CuttingWedgeFS, Shape
 
 
@@ -20,17 +20,9 @@ class ShellFS(Shape):
             to CadQuery.shell(). Defaults to intersection.
     """
 
-    def __init__(
-        self,
-        shape,
-        thickness=10.0,
-        kind='intersection',
-        **kwargs
-    ):
+    def __init__(self, shape, thickness=10.0, kind="intersection", **kwargs):
 
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
         self.shape = shape
         self.thickness = thickness
diff --git a/paramak/parametric_components/tf_coil_casing.py b/paramak/parametric_components/tf_coil_casing.py
index 153cde8d9..9dd4fe9ca 100644
--- a/paramak/parametric_components/tf_coil_casing.py
+++ b/paramak/parametric_components/tf_coil_casing.py
@@ -1,4 +1,3 @@
-
 import warnings
 from typing import Optional
 
@@ -31,9 +30,7 @@ def __init__(
 
         self.magnet = magnet
 
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
         self.inner_offset = inner_offset
         self.outer_offset = outer_offset
@@ -41,7 +38,8 @@ def __init__(
         self.leg_shape = ExtrudeStraightShape(
             distance=self.distance,
             azimuth_placement_angle=self.azimuth_placement_angle,
-            workplane=self.magnet.workplane)
+            workplane=self.magnet.workplane,
+        )
         self.inner_bore_cutting_points = None
         self.workplane = self.magnet.workplane
 
@@ -54,78 +52,77 @@ def azimuth_placement_angle(self):
     def azimuth_placement_angle(self, value):
         correct_angles = self.magnet.azimuth_placement_angle
         if value != correct_angles:
-            msg = ('Casing azimuth_placement_angle should be the'
-                   'same value as TFCoilCasing.magnet.')
+            msg = (
+                "Casing azimuth_placement_angle should be the"
+                "same value as TFCoilCasing.magnet."
+            )
             warnings.warn(msg, UserWarning)
         self._azimuth_placement_angle = correct_angles
 
     def find_points(self):
         inner_points_magnet = self.magnet.inner_points
         outer_points_magnet = self.magnet.outer_points
-        inner_points_magnet = (
-            inner_points_magnet[:, 0],
-            inner_points_magnet[:, 1]
-        )
-        outer_points_magnet = (
-            outer_points_magnet[:, 0],
-            outer_points_magnet[:, 1]
-        )
+        inner_points_magnet = (inner_points_magnet[:, 0], inner_points_magnet[:, 1])
+        outer_points_magnet = (outer_points_magnet[:, 0], outer_points_magnet[:, 1])
         inner_points = add_thickness(
             *inner_points_magnet,
             thickness=-self.inner_offset,
         )
 
-        outer_points = add_thickness(
-            *outer_points_magnet,
-            thickness=-self.outer_offset
-        )
+        outer_points = add_thickness(*outer_points_magnet, thickness=-self.outer_offset)
         curve_points = []
         for distrib_points in [inner_points, outer_points]:
-            curve_points.append([[R, Z, 'spline'] for R, Z in zip(
-                distrib_points[0], distrib_points[1])])
+            curve_points.append(
+                [[R, Z, "spline"] for R, Z in zip(distrib_points[0], distrib_points[1])]
+            )
 
-        curve_points[0][-1][2] = 'straight'
+        curve_points[0][-1][2] = "straight"
         curve_points[1][-1][2] = "straight"
 
         points = curve_points[0] + curve_points[1]
         self.points = points
 
-        yA = outer_points[1][outer_points[0].index(
-            min(outer_points[0], key=lambda x:abs(x - min(inner_points[0]))))]
+        ya = outer_points[1][
+            outer_points[0].index(
+                min(outer_points[0], key=lambda x: abs(x - min(inner_points[0])))
+            )
+        ]
         self.leg_points = [
             (
-                min(outer_points[0]) -
-                self.vertical_section_offset + self.outer_offset,
-                min(outer_points[1])),
+                min(outer_points[0]) - self.vertical_section_offset + self.outer_offset,
+                min(outer_points[1]),
+            ),
             (
                 outer_points[0][outer_points[1].index(min(outer_points[1]))],
-                min(outer_points[1])),
+                min(outer_points[1]),
+            ),
             (
                 inner_points[0][inner_points[1].index(min(inner_points[1]))],
-                min(inner_points[1])),
-            (min(inner_points[0]), min(
-                yA, self.magnet.vertical_displacement - yA)),
+                min(inner_points[1]),
+            ),
+            (min(inner_points[0]), min(ya, self.magnet.vertical_displacement - ya)),
             # not having this line avoid unexpected surfaces
             (inner_points[0][-1], inner_points[1][-1]),
-            (min(inner_points[0]), max(
-                yA, self.magnet.vertical_displacement - yA)),
+            (min(inner_points[0]), max(ya, self.magnet.vertical_displacement - ya)),
             (
                 inner_points[0][inner_points[1].index(min(inner_points[1]))],
-                max(inner_points[1])),
+                max(inner_points[1]),
+            ),
             (
                 outer_points[0][outer_points[1].index(min(outer_points[1]))],
-                max(outer_points[1])),
+                max(outer_points[1]),
+            ),
             (
-                min(outer_points[0]) - \
-                self.vertical_section_offset + self.outer_offset,
-                max(outer_points[1])),
+                min(outer_points[0]) - self.vertical_section_offset + self.outer_offset,
+                max(outer_points[1]),
+            ),
         ]
 
         self.inner_bore_cutting_points = [
             (0, self.leg_points[0][1]),
             self.leg_points[0],
             self.leg_points[-1],
-            (0, self.leg_points[-1][1])
+            (0, self.leg_points[-1][1]),
         ]
 
     def create_solid(self):
@@ -133,8 +130,7 @@ def create_solid(self):
 
         self.leg_shape.points = self.leg_points
         self.leg_shape.distance = self.distance
-        self.leg_shape.azimuth_placement_angle = \
-            self.azimuth_placement_angle
+        self.leg_shape.azimuth_placement_angle = self.azimuth_placement_angle
         solid = union_solid(solid, self.leg_shape)
         solid = cut_solid(solid, self.magnet)
 
@@ -142,7 +138,7 @@ def create_solid(self):
         inner_bore_cutting_shape = ExtrudeStraightShape(
             points=self.inner_bore_cutting_points,
             distance=self.distance,
-            azimuth_placement_angle=self.azimuth_placement_angle
+            azimuth_placement_angle=self.azimuth_placement_angle,
         )
         solid = cut_solid(solid, inner_bore_cutting_shape)
 
diff --git a/paramak/parametric_components/tokamak_plasma.py b/paramak/parametric_components/tokamak_plasma.py
index b838d3ddd..2818c62b3 100644
--- a/paramak/parametric_components/tokamak_plasma.py
+++ b/paramak/parametric_components/tokamak_plasma.py
@@ -1,5 +1,5 @@
-
 import numpy as np
+
 from paramak import RotateSplineShape
 
 
@@ -42,10 +42,7 @@ def __init__(
         **kwargs
     ):
 
-        super().__init__(
-            name=name,
-            **kwargs
-        )
+        super().__init__(name=name, **kwargs)
 
         # properties needed for plasma shapes
         self.elongation = elongation
@@ -89,7 +86,9 @@ def low_point(self, value):
     @property
     def outer_equatorial_point(self):
         self.outer_equatorial_point = (
-            self.major_radius + self.minor_radius, self.vertical_displacement)
+            self.major_radius + self.minor_radius,
+            self.vertical_displacement,
+        )
         return self._outer_equatorial_point
 
     @outer_equatorial_point.setter
@@ -99,7 +98,9 @@ def outer_equatorial_point(self, value):
     @property
     def inner_equatorial_point(self):
         self.inner_equatorial_point = (
-            self.major_radius - self.minor_radius, self.vertical_displacement)
+            self.major_radius - self.minor_radius,
+            self.vertical_displacement,
+        )
         return self._inner_equatorial_point
 
     @inner_equatorial_point.setter
@@ -179,16 +180,11 @@ def compute_x_points(self):
         triangularity = self.triangularity
         if self.configuration in ["single-null", "double-null"]:
             # no X points for non-null config
-            lower_x_point = (1 -
-                             (1 +
-                              shift) *
-                             triangularity *
-                             self.minor_radius, -
-                             (1 +
-                              shift) *
-                             elongation *
-                             self.minor_radius +
-                             self.vertical_displacement, )
+            lower_x_point = (
+                1 - (1 + shift) * triangularity * self.minor_radius,
+                -(1 + shift) * elongation * self.minor_radius
+                + self.vertical_displacement,
+            )
 
             if self.configuration == "double-null":
                 # upper_x_point is up-down symmetrical
diff --git a/paramak/parametric_components/tokamak_plasma_from_points.py b/paramak/parametric_components/tokamak_plasma_from_points.py
index 749b0ab52..f1ceea853 100644
--- a/paramak/parametric_components/tokamak_plasma_from_points.py
+++ b/paramak/parametric_components/tokamak_plasma_from_points.py
@@ -1,4 +1,3 @@
-
 from paramak import Plasma
 
 
@@ -16,15 +15,10 @@ class PlasmaFromPoints(Plasma):
     """
 
     def __init__(
-        self,
-        outer_equatorial_x_point,
-        inner_equatorial_x_point,
-        high_point,
-        **kwargs
+        self, outer_equatorial_x_point, inner_equatorial_x_point, high_point, **kwargs
     ):
 
-        minor_radius = (outer_equatorial_x_point -
-                        inner_equatorial_x_point) / 2.0
+        minor_radius = (outer_equatorial_x_point - inner_equatorial_x_point) / 2.0
         major_radius = inner_equatorial_x_point + minor_radius
         elongation = high_point[1] / minor_radius
         triangularity = (major_radius - high_point[0]) / minor_radius
diff --git a/paramak/parametric_components/tokamak_plasma_plasmaboundaries.py b/paramak/parametric_components/tokamak_plasma_plasmaboundaries.py
index 11fb88358..adc4cd670 100644
--- a/paramak/parametric_components/tokamak_plasma_plasmaboundaries.py
+++ b/paramak/parametric_components/tokamak_plasma_plasmaboundaries.py
@@ -1,6 +1,6 @@
+from plasmaboundaries import get_separatrix_coordinates
 
 from paramak import Plasma
-from plasmaboundaries import get_separatrix_coordinates
 
 
 class PlasmaBoundaries(Plasma):
@@ -65,8 +65,7 @@ def find_points(self):
             "elongation": self.elongation,
             "triangularity": self.triangularity,
         }
-        points = get_separatrix_coordinates(
-            params, self.configuration)
+        points = get_separatrix_coordinates(params, self.configuration)
         # add vertical displacement
         points[:, 1] += self.vertical_displacement
         # rescale to cm
@@ -83,5 +82,6 @@ def find_points(self):
                 upper_point_y = self.upper_x_point[1]
 
         points = points[
-            (points[:, 1] >= lower_point_y) & (points[:, 1] <= upper_point_y)]
+            (points[:, 1] >= lower_point_y) & (points[:, 1] <= upper_point_y)
+        ]
         self.points = points.tolist()[:-1]
diff --git a/paramak/parametric_components/toroidal_field_coil_coat_hanger.py b/paramak/parametric_components/toroidal_field_coil_coat_hanger.py
index 6498deab9..89a1ed31b 100644
--- a/paramak/parametric_components/toroidal_field_coil_coat_hanger.py
+++ b/paramak/parametric_components/toroidal_field_coil_coat_hanger.py
@@ -1,9 +1,9 @@
-
 import math
-
 from typing import Optional, Tuple
+
 import cadquery as cq
 import numpy as np
+
 from paramak import ExtrudeStraightShape
 from paramak.utils import calculate_wedge_cut, rotate
 
@@ -38,15 +38,11 @@ def __init__(
         distance: float,
         number_of_coils: int,
         with_inner_leg: Optional[bool] = True,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0., 0., 1.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.0, 0.0, 1.0),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=distance,
-            color=color,
-            **kwargs
-        )
+        super().__init__(distance=distance, color=color, **kwargs)
 
         self.horizontal_start_point = horizontal_start_point
         self.horizontal_length = horizontal_length
@@ -93,9 +89,11 @@ def find_points(self):
         # 7---8
 
         adjacent_length = self.vertical_mid_point[0] - (
-            self.horizontal_start_point[0] + self.horizontal_length)
+            self.horizontal_start_point[0] + self.horizontal_length
+        )
         oppersite_length = self.horizontal_start_point[1] - (
-            self.vertical_mid_point[1] + 0.5 * self.vertical_length)
+            self.vertical_mid_point[1] + 0.5 * self.vertical_length
+        )
 
         point_rotation = math.atan(oppersite_length / adjacent_length)
         point_rotation_mid = math.radians(90) - point_rotation
@@ -139,7 +137,7 @@ def find_points(self):
                     self.horizontal_start_point[0] + self.horizontal_length,
                     -self.horizontal_start_point[1] - self.thickness,
                 ),  # same as point 8
-                point_rotation
+                point_rotation,
             ),  # point 9
             rotate(
                 (
@@ -150,7 +148,7 @@ def find_points(self):
                     self.vertical_mid_point[0] + self.thickness,
                     self.vertical_mid_point[1] - 0.5 * self.vertical_length,
                 ),  # same as point 11
-                -point_rotation_mid
+                -point_rotation_mid,
             ),  # point 10
             (
                 self.vertical_mid_point[0] + self.thickness,
@@ -169,7 +167,7 @@ def find_points(self):
                     self.vertical_mid_point[0] + self.thickness,
                     self.vertical_mid_point[1] + 0.5 * self.vertical_length,
                 ),  # same as point 12
-                point_rotation_mid
+                point_rotation_mid,
             ),  # point 13
             rotate(
                 (
@@ -180,7 +178,7 @@ def find_points(self):
                     self.horizontal_start_point[0] + self.horizontal_length,
                     self.horizontal_start_point[1] + self.thickness,
                 ),  # same as point 15
-                -point_rotation
+                -point_rotation,
             ),  # point 14
             (
                 self.horizontal_start_point[0] + self.horizontal_length,
@@ -189,7 +187,7 @@ def find_points(self):
             (
                 self.horizontal_start_point[0],
                 self.horizontal_start_point[1] + self.thickness,
-            )   # point 16
+            ),  # point 16
         ]
 
         self.inner_leg_connection_points = [
@@ -205,12 +203,7 @@ def find_azimuth_placement_angle(self):
         """Calculates the azimuth placement angles based on the number of
         toroidal field coils"""
 
-        angles = list(
-            np.linspace(
-                0,
-                360,
-                self.number_of_coils,
-                endpoint=False))
+        angles = list(np.linspace(0, 360, self.number_of_coils, endpoint=False))
 
         self.azimuth_placement_angle = angles
 
@@ -223,10 +216,7 @@ def create_solid(self):
 
         # Creates a cadquery solid from points and revolves
         points_without_connections = [p[:2] for p in self.points]
-        solid = (
-            cq.Workplane(self.workplane)
-            .polyline(points_without_connections)
-        )
+        solid = cq.Workplane(self.workplane).polyline(points_without_connections)
 
         wire = solid.close()
 
@@ -241,19 +231,20 @@ def create_solid(self):
 
         if self.with_inner_leg is True:
             inner_leg_solid = cq.Workplane(self.workplane)
-            inner_leg_solid = inner_leg_solid.polyline(
-                self.inner_leg_connection_points)
+            inner_leg_solid = inner_leg_solid.polyline(self.inner_leg_connection_points)
             inner_leg_solid = inner_leg_solid.close().extrude(
-                distance=-self.distance / 2.0, both=True)
+                distance=-self.distance / 2.0, both=True
+            )
 
             inner_leg_solid = self.rotate_solid(inner_leg_solid)
             inner_leg_solid = self.perform_boolean_operations(
-                inner_leg_solid, wedge_cut=cutting_wedge)
+                inner_leg_solid, wedge_cut=cutting_wedge
+            )
 
             solid = cq.Compound.makeCompound(
                 [a.val() for a in [inner_leg_solid, solid]]
             )
 
-        self.solid = solid   # not necessarily required as set in boolean_operations
+        self.solid = solid  # not necessarily required as set in boolean_operations
 
         return solid
diff --git a/paramak/parametric_components/toroidal_field_coil_princeton_d.py b/paramak/parametric_components/toroidal_field_coil_princeton_d.py
index 84a3676a3..35a89412d 100644
--- a/paramak/parametric_components/toroidal_field_coil_princeton_d.py
+++ b/paramak/parametric_components/toroidal_field_coil_princeton_d.py
@@ -1,12 +1,12 @@
-
 from typing import Optional, Tuple
 
 import numpy as np
-from paramak import ExtrudeMixedShape
-from paramak.utils import add_thickness
 from scipy import integrate
 from scipy.optimize import minimize
 
+from paramak import ExtrudeMixedShape
+from paramak.utils import add_thickness
+
 
 class ToroidalFieldCoilPrincetonD(ExtrudeMixedShape):
     """Toroidal field coil based on Princeton-D curve
@@ -32,15 +32,11 @@ def __init__(
         number_of_coils: int,
         vertical_displacement: Optional[float] = 0.0,
         with_inner_leg: Optional[bool] = True,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0., 0., 1.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.0, 0.0, 1.0),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=distance,
-            color=color,
-            **kwargs
-        )
+        super().__init__(distance=distance, color=color, **kwargs)
 
         self.R1 = R1
         self.R2 = R2
@@ -88,6 +84,7 @@ def _compute_inner_points(self, R1, R2):
             (list, list, list): R, Z and derivative lists for outer curve
             points
         """
+
         def error(z_0, R0, R2):
             segment = get_segment(R0, R2, z_0)
             return abs(segment[1][-1])
@@ -98,9 +95,9 @@ def get_segment(a, b, z_0):
             return a_R, asol[:, 0], asol[:, 1]
 
         def solvr(Y, R):
-            return [Y[1], -1 / (k * R) * (1 + Y[1]**2)**(3 / 2)]
+            return [Y[1], -1 / (k * R) * (1 + Y[1] ** 2) ** (3 / 2)]
 
-        R0 = (R1 * R2)**0.5
+        R0 = (R1 * R2) ** 0.5
         k = 0.5 * np.log(R2 / R1)
 
         # computing of z_0
@@ -113,72 +110,76 @@ def solvr(Y, R):
         segment1 = get_segment(R0, R1, z_0)
         segment2 = get_segment(R0, R2, z_0)
 
-        R = np.concatenate([np.flip(segment1[0]), segment2[0]
-                            [1:], np.flip(segment2[0])[1:], segment1[0][1:]])
-        Z = np.concatenate([np.flip(segment1[1]), segment2[1]
-                            [1:], -np.flip(segment2[1])[1:], -segment1[1][1:]])
-        return R, Z
+        r_values = np.concatenate(
+            [
+                np.flip(segment1[0]),
+                segment2[0][1:],
+                np.flip(segment2[0])[1:],
+                segment1[0][1:],
+            ]
+        )
+        z_values = np.concatenate(
+            [
+                np.flip(segment1[1]),
+                segment2[1][1:],
+                -np.flip(segment2[1])[1:],
+                -segment1[1][1:],
+            ]
+        )
+        return r_values, z_values
 
     def find_points(self):
         """Finds the XZ points joined by connections that describe the 2D
         profile of the toroidal field coil shape."""
         # compute inner points
-        R_inner, Z_inner = self._compute_inner_points(
-            self.R1 + self.thickness, self.R2)
+        r_inner, z_inner = self._compute_inner_points(self.R1 + self.thickness, self.R2)
 
         # compute outer points
-        dz_dr = np.diff(Z_inner) / np.diff(R_inner)
+        dz_dr = np.diff(z_inner) / np.diff(r_inner)
         dz_dr[0] = float("-inf")
         dz_dr = np.append(dz_dr, float("inf"))
-        R_outer, Z_outer = add_thickness(
-            R_inner, Z_inner, self.thickness, dy_dx=dz_dr
-        )
-        R_outer, Z_outer = np.flip(R_outer), np.flip(Z_outer)
+        r_outer, z_outer = add_thickness(r_inner, z_inner, self.thickness, dy_dx=dz_dr)
+        r_outer, z_outer = np.flip(r_outer), np.flip(z_outer)
 
         # add vertical displacement
-        Z_outer += self.vertical_displacement
-        Z_inner += self.vertical_displacement
+        z_outer += self.vertical_displacement
+        z_inner += self.vertical_displacement
 
         # extract helping points for inner leg
         inner_leg_connection_points = [
-            (R_inner[0], Z_inner[0]),
-            (R_inner[-1], Z_inner[-1]),
-            (R_outer[0], Z_outer[0]),
-            (R_outer[-1], Z_outer[-1])
+            (r_inner[0], z_inner[0]),
+            (r_inner[-1], z_inner[-1]),
+            (r_outer[0], z_outer[0]),
+            (r_outer[-1], z_outer[-1]),
         ]
         self.inner_leg_connection_points = inner_leg_connection_points
 
         # add the leg to the points
         if self.with_inner_leg:
-            R_inner = np.append(R_inner, R_inner[0])
-            Z_inner = np.append(Z_inner, Z_inner[0])
+            r_inner = np.append(r_inner, r_inner[0])
+            z_inner = np.append(z_inner, z_inner[0])
 
-            R_outer = np.append(R_outer, R_outer[0])
-            Z_outer = np.append(Z_outer, Z_outer[0])
+            r_outer = np.append(r_outer, r_outer[0])
+            z_outer = np.append(z_outer, z_outer[0])
         # add connections
-        inner_points = [[r, z, 'spline'] for r, z in zip(R_inner, Z_inner)]
-        outer_points = [[r, z, 'spline'] for r, z in zip(R_outer, Z_outer)]
+        inner_points = [[r, z, "spline"] for r, z in zip(r_inner, z_inner)]
+        outer_points = [[r, z, "spline"] for r, z in zip(r_outer, z_outer)]
         if self.with_inner_leg:
-            outer_points[-2][2] = 'straight'
-            inner_points[-2][2] = 'straight'
+            outer_points[-2][2] = "straight"
+            inner_points[-2][2] = "straight"
 
-        inner_points[-1][2] = 'straight'
-        outer_points[-1][2] = 'straight'
+        inner_points[-1][2] = "straight"
+        outer_points[-1][2] = "straight"
 
         points = inner_points + outer_points
-        self.outer_points = np.vstack((R_outer, Z_outer)).T
-        self.inner_points = np.vstack((R_inner, Z_inner)).T
+        self.outer_points = np.vstack((r_outer, z_outer)).T
+        self.inner_points = np.vstack((r_inner, z_inner)).T
         self.points = points
 
     def find_azimuth_placement_angle(self):
         """Calculates the azimuth placement angles based on the number of tf
         coils"""
 
-        angles = list(
-            np.linspace(
-                0,
-                360,
-                self.number_of_coils,
-                endpoint=False))
+        angles = list(np.linspace(0, 360, self.number_of_coils, endpoint=False))
 
         self.azimuth_placement_angle = angles
diff --git a/paramak/parametric_components/toroidal_field_coil_rectangle.py b/paramak/parametric_components/toroidal_field_coil_rectangle.py
index 38dccbb21..08c3b115e 100644
--- a/paramak/parametric_components/toroidal_field_coil_rectangle.py
+++ b/paramak/parametric_components/toroidal_field_coil_rectangle.py
@@ -1,7 +1,8 @@
-
 from typing import Optional, Tuple
+
 import cadquery as cq
 import numpy as np
+
 from paramak import ExtrudeStraightShape
 from paramak.utils import calculate_wedge_cut
 
@@ -30,15 +31,11 @@ def __init__(
         distance: float,
         number_of_coils: int,
         with_inner_leg: Optional[bool] = True,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0., 0., 1.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.0, 0.0, 1.0),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=distance,
-            color=color,
-            **kwargs
-        )
+        super().__init__(distance=distance, color=color, **kwargs)
 
         self.horizontal_start_point = horizontal_start_point
         self.vertical_mid_point = vertical_mid_point
@@ -62,41 +59,50 @@ def find_points(self):
 
         if self.horizontal_start_point[0] >= self.vertical_mid_point[0]:
             raise ValueError(
-                'horizontal_start_point x should be smaller than the \
-                    vertical_mid_point x value')
+                "horizontal_start_point x should be smaller than the \
+                    vertical_mid_point x value"
+            )
         if self.vertical_mid_point[1] >= self.horizontal_start_point[1]:
             raise ValueError(
-                'vertical_mid_point y value should be smaller than the \
-                    horizontal_start_point y value')
+                "vertical_mid_point y value should be smaller than the \
+                    horizontal_start_point y value"
+            )
 
         points = [
             self.horizontal_start_point,  # connection point
             # connection point
-            (self.horizontal_start_point[0] +
-             self.thickness, self.horizontal_start_point[1]),
+            (
+                self.horizontal_start_point[0] + self.thickness,
+                self.horizontal_start_point[1],
+            ),
             (self.vertical_mid_point[0], self.horizontal_start_point[1]),
             (self.vertical_mid_point[0], -self.horizontal_start_point[1]),
             # connection point
-            (self.horizontal_start_point[0] +
-             self.thickness, -
-             self.horizontal_start_point[1]),
+            (
+                self.horizontal_start_point[0] + self.thickness,
+                -self.horizontal_start_point[1],
+            ),
             # connection point
             (self.horizontal_start_point[0], -self.horizontal_start_point[1]),
-            (self.horizontal_start_point[0], -
-             (self.horizontal_start_point[1] +
-                self.thickness)),
-            (self.vertical_mid_point[0] +
-             self.thickness, -
-             (self.horizontal_start_point[1] +
-                self.thickness)),
-            (self.vertical_mid_point[0] + self.thickness,
-             self.horizontal_start_point[1] + self.thickness),
-            (self.horizontal_start_point[0],
-             self.horizontal_start_point[1] + self.thickness),
+            (
+                self.horizontal_start_point[0],
+                -(self.horizontal_start_point[1] + self.thickness),
+            ),
+            (
+                self.vertical_mid_point[0] + self.thickness,
+                -(self.horizontal_start_point[1] + self.thickness),
+            ),
+            (
+                self.vertical_mid_point[0] + self.thickness,
+                self.horizontal_start_point[1] + self.thickness,
+            ),
+            (
+                self.horizontal_start_point[0],
+                self.horizontal_start_point[1] + self.thickness,
+            ),
         ]
 
-        self.inner_leg_connection_points = [
-            points[0], points[1], points[4], points[5]]
+        self.inner_leg_connection_points = [points[0], points[1], points[4], points[5]]
 
         self.points = points
 
@@ -104,12 +110,7 @@ def find_azimuth_placement_angle(self):
         """Calculates the azimuth placement angles based on the number of tf
         coils"""
 
-        angles = list(
-            np.linspace(
-                0,
-                360,
-                self.number_of_coils,
-                endpoint=False))
+        angles = list(np.linspace(0, 360, self.number_of_coils, endpoint=False))
 
         self.azimuth_placement_angle = angles
 
@@ -122,10 +123,7 @@ def create_solid(self):
 
         # Creates a cadquery solid from points and revolves
         points_without_connections = [p[:2] for p in self.points]
-        solid = (
-            cq.Workplane(self.workplane)
-            .polyline(points_without_connections)
-        )
+        solid = cq.Workplane(self.workplane).polyline(points_without_connections)
 
         wire = solid.close()
 
@@ -140,19 +138,20 @@ def create_solid(self):
 
         if self.with_inner_leg is True:
             inner_leg_solid = cq.Workplane(self.workplane)
-            inner_leg_solid = inner_leg_solid.polyline(
-                self.inner_leg_connection_points)
+            inner_leg_solid = inner_leg_solid.polyline(self.inner_leg_connection_points)
             inner_leg_solid = inner_leg_solid.close().extrude(
-                distance=-self.distance / 2.0, both=True)
+                distance=-self.distance / 2.0, both=True
+            )
 
             inner_leg_solid = self.rotate_solid(inner_leg_solid)
             inner_leg_solid = self.perform_boolean_operations(
-                inner_leg_solid, wedge_cut=cutting_wedge)
+                inner_leg_solid, wedge_cut=cutting_wedge
+            )
 
             solid = cq.Compound.makeCompound(
                 [a.val() for a in [inner_leg_solid, solid]]
             )
 
-        self.solid = solid   # not necessarily required as set in boolean_operations
+        self.solid = solid  # not necessarily required as set in boolean_operations
 
         return solid
diff --git a/paramak/parametric_components/toroidal_field_coil_round_corners.py b/paramak/parametric_components/toroidal_field_coil_round_corners.py
index 2f023b20d..5d80b6679 100644
--- a/paramak/parametric_components/toroidal_field_coil_round_corners.py
+++ b/paramak/parametric_components/toroidal_field_coil_round_corners.py
@@ -2,6 +2,7 @@
 
 import cadquery as cq
 import numpy as np
+
 from paramak.parametric_shapes.extruded_mixed_shape import ExtrudeMixedShape
 from paramak.utils import calculate_wedge_cut
 
@@ -39,10 +40,7 @@ def __init__(
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=distance,
-            **kwargs
-        )
+        super().__init__(distance=distance, **kwargs)
 
         self._lower_inner_coordinates = lower_inner_coordinates
         self._mid_point_coordinates = mid_point_coordinates
@@ -51,38 +49,37 @@ def __init__(
         self.number_of_coils = number_of_coils
         self._with_inner_leg = with_inner_leg
         self._inner_leg_connection_points = []
-        self._analyse_attributes = [
-            0,
-            0,
-            0,
-            0
-        ]
+        self._analyse_attributes = [0, 0, 0, 0]
         self._base_length = 0
         self._height = 0
         self._inner_curve_radius = 0
         self._outter_curve_radius = 0
 
-        if len(lower_inner_coordinates) != 2 or len(
-                mid_point_coordinates) != 2:
-            msg = ('The input tuples are too long or too short, they must be '
-                   '2 element long')
+        if len(lower_inner_coordinates) != 2 or len(mid_point_coordinates) != 2:
+            msg = (
+                "The input tuples are too long or too short, they must be "
+                "2 element long"
+            )
             raise ValueError(msg)
 
         if self._lower_inner_coordinates[0] > self._mid_point_coordinates[0]:
             raise ValueError(
                 "The middle point's x-coordinate must be larger than the lower",
-                "inner point's x-coordinate")
+                "inner point's x-coordinate",
+            )
 
     def _find_base_and_height(self):
         # Adding hidden attributes for analyse list population
         # inner base length of the coil
-        self._base_length = self._mid_point_coordinates[0] - \
-            self._lower_inner_coordinates[0]
+        self._base_length = (
+            self._mid_point_coordinates[0] - self._lower_inner_coordinates[0]
+        )
         self._analyse_attributes[0] = self._base_length
 
         # height of the coil
-        self._height = abs(
-            self.mid_point_coordinates[1] - self.lower_inner_coordinates[1]) * 2
+        self._height = (
+            abs(self.mid_point_coordinates[1] - self.lower_inner_coordinates[1]) * 2
+        )
         self._analyse_attributes[1] = self._height
 
     def _find_radii(self):
@@ -99,8 +96,9 @@ def _find_radii(self):
             self._outter_curve_radius = self._thickness * 1.1
         else:
             self._outter_curve_radius = (
-                1 + (self._thickness / self._base_length)) * self._thickness
-            self._inner_curve_radius = (self._thickness**2) / self._base_length
+                1 + (self._thickness / self._base_length)
+            ) * self._thickness
+            self._inner_curve_radius = (self._thickness ** 2) / self._base_length
 
         self._analyse_attributes[2] = self._inner_curve_radius
         self._analyse_attributes[3] = self._outter_curve_radius
@@ -130,7 +128,8 @@ def lower_inner_coordinates(self, val):
             raise TypeError("Input Z Coordinates must be a number!")
         if val[0] > self._mid_point_coordinates[0]:
             raise ValueError(
-                "Mid Point's x-coordinate, must be larger than lower point's!")
+                "Mid Point's x-coordinate, must be larger than lower point's!"
+            )
         self._lower_inner_coordinates = val
 
     @property
@@ -149,7 +148,8 @@ def mid_point_coordinates(self, val):
             raise TypeError("Input Z Coordinates must be a number!")
         if val[0] < self._lower_inner_coordinates[0]:
             raise ValueError(
-                "Mid Point's x-coordinate, must be larger than lower point's!")
+                "Mid Point's x-coordinate, must be larger than lower point's!"
+            )
         self._mid_point_coordinates = val
 
     @property
@@ -209,8 +209,13 @@ def find_points(self):
         mid_x, mid_z = self._mid_point_coordinates
 
         # redifine values to be floats to make it look consistent
-        lower_x, lower_z, mid_x, mid_z, thickness = float(lower_x), float(
-            lower_z), float(mid_x), float(mid_z), float(self._thickness)
+        lower_x, lower_z, mid_x, mid_z, thickness = (
+            float(lower_x),
+            float(lower_z),
+            float(mid_x),
+            float(mid_z),
+            float(self._thickness),
+        )
 
         # Define differences to avoid miss claculation due to signs
         base_length = self._analyse_attributes[0]
@@ -223,9 +228,9 @@ def find_points(self):
         point4 = (point1[0], point1[1] + height)
         point5 = (point4[0], point4[1] + thickness)
         point6 = (point3[0], point4[1] + thickness)
-        #point7 = (point3[0] + thickness, point3[1])
+        # point7 = (point3[0] + thickness, point3[1])
         point8 = (point2[0] + thickness, point2[1])
-        #point9 = (point2[0], point2[1] - thickness)
+        # point9 = (point2[0], point2[1] - thickness)
         point10 = (lower_x, lower_z - thickness)
 
         inner_curve_radius = self._analyse_attributes[2]
@@ -238,23 +243,29 @@ def find_points(self):
 
         def shift_long(radius):
             """radius is the radius of curvature"""
-            return (2**0.5) * 0.5 * radius
+            return (2 ** 0.5) * 0.5 * radius
 
         def shift_short(radius):
             """radius is the radius of curvature"""
-            return (2 - (2**0.5)) * 0.5 * radius
+            return (2 - (2 ** 0.5)) * 0.5 * radius
 
         point11 = (point2[0] - inner_curve_radius, point2[1])
-        point12 = (point11[0] + shift_long(inner_curve_radius),
-                   point11[1] + shift_short(inner_curve_radius))
+        point12 = (
+            point11[0] + shift_long(inner_curve_radius),
+            point11[1] + shift_short(inner_curve_radius),
+        )
         point13 = (point2[0], point2[1] + inner_curve_radius)
         point14 = (point3[0], point3[1] - inner_curve_radius)
-        point15 = (point14[0] - shift_short(inner_curve_radius),
-                   point14[1] + shift_long(inner_curve_radius))
+        point15 = (
+            point14[0] - shift_short(inner_curve_radius),
+            point14[1] + shift_long(inner_curve_radius),
+        )
         point16 = (point3[0] - inner_curve_radius, point3[1])
         point17 = (point6[0] - inner_curve_radius, point6[1])
-        point18 = (point17[0] + shift_long(outter_curve_radius),
-                   point17[1] - shift_short(outter_curve_radius))
+        point18 = (
+            point17[0] + shift_long(outter_curve_radius),
+            point17[1] - shift_short(outter_curve_radius),
+        )
         point19 = (point14[0] + thickness, point14[1])
         point20 = (point8[0], point8[1] + inner_curve_radius)
         point21 = (point18[0], point20[1] - shift_long(outter_curve_radius))
@@ -277,12 +288,21 @@ def shift_short(radius):
             point20,
             point21,
             point22,
-            point10]
+            point10,
+        ]
         # List that holds the points with the corresponding line types
         tri_points = []
-        lines = ["straight"] + ['circle'] * 2 + ['straight'] \
-            + ['circle'] * 2 + ['straight'] * 3 + ['circle'] * 2 \
-            + ['straight'] + ['circle'] * 2 + ['straight'] * 2
+        lines = (
+            ["straight"]
+            + ["circle"] * 2
+            + ["straight"]
+            + ["circle"] * 2
+            + ["straight"] * 3
+            + ["circle"] * 2
+            + ["straight"]
+            + ["circle"] * 2
+            + ["straight"] * 2
+        )
 
         for i in enumerate(points):
             tri_points.append(points[i[0]] + (lines[i[0]],))
@@ -295,44 +315,52 @@ def shift_short(radius):
         inner_point4 = (point4[0], point4[1])
 
         self._inner_leg_connection_points = [
-            inner_point1, inner_point2, inner_point3, inner_point4]
+            inner_point1,
+            inner_point2,
+            inner_point3,
+            inner_point4,
+        ]
 
         return tri_points
 
     def find_azimuth_placement_angle(self):
-        """ Finds the placement angles from the number of coils
-            given in a 360 degree """
-
-        angles = list(
-            np.linspace(
-                0,
-                360,
-                self._number_of_coils,
-                endpoint=False))
+        """Finds the placement angles from the number of coils
+        given in a 360 degree"""
+
+        angles = list(np.linspace(0, 360, self._number_of_coils, endpoint=False))
         self.azimuth_placement_angle = angles
 
     def create_solid(self):
-        """ Creates a Cadquery 3D geometry
+        """Creates a Cadquery 3D geometry
 
         Returns:
-            CadQuery solid: A 3D solid Volume """
+            CadQuery solid: A 3D solid Volume"""
 
         # Create solid from points
         points = [ps[:2] for ps in self.processed_points]
 
-        wire = cq.Workplane(self.workplane).moveTo(points[0][0], points[0][1]) \
-            .lineTo(points[1][0], points[1][1]) \
-            .threePointArc((points[2][0], points[2][1]), (points[3][0], points[3][1])) \
-            .lineTo(points[4][0], points[4][1]) \
-            .threePointArc((points[5][0], points[5][1]), (points[6][0], points[6][1])) \
-            .lineTo(points[7][0], points[7][1]) \
-            .lineTo(points[8][0], points[8][1]) \
-            .lineTo(points[9][0], points[9][1]) \
-            .threePointArc((points[10][0], points[10][1]), (points[11][0], points[11][1])) \
-            .lineTo(points[12][0], points[12][1]) \
-            .threePointArc((points[13][0], points[13][1]), (points[14][0], points[14][1])) \
-            .lineTo(points[15][0], points[15][1]) \
-            .lineTo(points[16][0], points[16][1]).close().consolidateWires()
+        wire = (
+            cq.Workplane(self.workplane)
+            .moveTo(points[0][0], points[0][1])
+            .lineTo(points[1][0], points[1][1])
+            .threePointArc((points[2][0], points[2][1]), (points[3][0], points[3][1]))
+            .lineTo(points[4][0], points[4][1])
+            .threePointArc((points[5][0], points[5][1]), (points[6][0], points[6][1]))
+            .lineTo(points[7][0], points[7][1])
+            .lineTo(points[8][0], points[8][1])
+            .lineTo(points[9][0], points[9][1])
+            .threePointArc(
+                (points[10][0], points[10][1]), (points[11][0], points[11][1])
+            )
+            .lineTo(points[12][0], points[12][1])
+            .threePointArc(
+                (points[13][0], points[13][1]), (points[14][0], points[14][1])
+            )
+            .lineTo(points[15][0], points[15][1])
+            .lineTo(points[16][0], points[16][1])
+            .close()
+            .consolidateWires()
+        )
 
         solid = wire.extrude(distance=-self._distance / 2, both=True)
         solid = self.rotate_solid(solid)
@@ -344,16 +372,20 @@ def create_solid(self):
 
         if self._with_inner_leg:
             inner_leg_solid = cq.Workplane(self.workplane)
-            inner_leg_solid = inner_leg_solid.polyline(
-                self._inner_leg_connection_points).close().extrude(
-                distance=-self._distance / 2, both=True)
+            inner_leg_solid = (
+                inner_leg_solid.polyline(self._inner_leg_connection_points)
+                .close()
+                .extrude(distance=-self._distance / 2, both=True)
+            )
 
             inner_leg_solid = self.rotate_solid(inner_leg_solid)
             inner_leg_solid = self.perform_boolean_operations(
-                inner_leg_solid, wedge_cut=cutting_wedge)
+                inner_leg_solid, wedge_cut=cutting_wedge
+            )
 
             solid = cq.Compound.makeCompound(
-                [a.val() for a in [inner_leg_solid, solid]])
+                [a.val() for a in [inner_leg_solid, solid]]
+            )
 
             self.solid = solid
 
diff --git a/paramak/parametric_components/toroidal_field_coil_triple_arc.py b/paramak/parametric_components/toroidal_field_coil_triple_arc.py
index 73cbfb841..6887999a6 100644
--- a/paramak/parametric_components/toroidal_field_coil_triple_arc.py
+++ b/paramak/parametric_components/toroidal_field_coil_triple_arc.py
@@ -1,6 +1,7 @@
-
 from typing import Optional, Tuple
+
 import numpy as np
+
 from paramak import ExtrudeMixedShape
 
 
@@ -32,15 +33,11 @@ def __init__(
         number_of_coils: int,
         vertical_displacement: Optional[float] = 0.0,
         with_inner_leg: Optional[bool] = True,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0., 0., 1.),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.0, 0.0, 1.0),
         **kwargs
     ) -> None:
 
-        super().__init__(
-            distance=distance,
-            color=color,
-            **kwargs
-        )
+        super().__init__(distance=distance, color=color, **kwargs)
         self.R1 = R1
         self.h = h
         self.small_radius, self.mid_radius = radii
@@ -70,25 +67,31 @@ def _compute_curve(self, R1, h, radii, coverages):
 
         # small arc
         theta = np.linspace(
-            0, small_coverage, round(0.5 * npoints * small_coverage / np.pi))
+            0, small_coverage, round(0.5 * npoints * small_coverage / np.pi)
+        )
         small_arc_R = R1 + small_radius * (1 - np.cos(theta))
         small_arc_Z = h + small_radius * np.sin(theta)
 
         # mid arc
         theta = np.linspace(
-            theta[-1], asum, round(0.5 * npoints * mid_coverage / np.pi))
-        mid_arc_R = small_arc_R[-1] + mid_radius * \
-            (np.cos(small_coverage) - np.cos(theta))
-        mid_arc_Z = small_arc_Z[-1] + mid_radius * \
-            (np.sin(theta) - np.sin(small_coverage))
+            theta[-1], asum, round(0.5 * npoints * mid_coverage / np.pi)
+        )
+        mid_arc_R = small_arc_R[-1] + mid_radius * (
+            np.cos(small_coverage) - np.cos(theta)
+        )
+        mid_arc_Z = small_arc_Z[-1] + mid_radius * (
+            np.sin(theta) - np.sin(small_coverage)
+        )
 
         # large arc
         large_radius = (mid_arc_Z[-1]) / np.sin(np.pi - asum)
         theta = np.linspace(theta[-1], np.pi, 60)
-        large_arc_R = mid_arc_R[-1] + large_radius * \
-            (np.cos(np.pi - theta) - np.cos(np.pi - asum))
-        large_arc_Z = mid_arc_Z[-1] - large_radius * \
-            (np.sin(asum) - np.sin(np.pi - theta))
+        large_arc_R = mid_arc_R[-1] + large_radius * (
+            np.cos(np.pi - theta) - np.cos(np.pi - asum)
+        )
+        large_arc_Z = mid_arc_Z[-1] - large_radius * (
+            np.sin(asum) - np.sin(np.pi - theta)
+        )
 
         R = np.concatenate((small_arc_R, mid_arc_R[1:], large_arc_R[1:]))
         R = np.append(R, np.flip(R)[1:])
@@ -108,14 +111,19 @@ def find_points(self):
 
         # create inner coordinates
         R_inner, Z_inner = self._compute_curve(
-            self.R1 + thickness, self.h * 0.5, radii=(small_radius, mid_radius),
-            coverages=(small_coverage, mid_coverage))
+            self.R1 + thickness,
+            self.h * 0.5,
+            radii=(small_radius, mid_radius),
+            coverages=(small_coverage, mid_coverage),
+        )
 
         # create outer coordinates
         R_outer, Z_outer = self._compute_curve(
-            self.R1, self.h * 0.5,
+            self.R1,
+            self.h * 0.5,
             radii=(small_radius + thickness, mid_radius + thickness),
-            coverages=(small_coverage, mid_coverage))
+            coverages=(small_coverage, mid_coverage),
+        )
         R_outer, Z_outer = np.flip(R_outer), np.flip(Z_outer)
 
         # add vertical displacement
@@ -127,7 +135,7 @@ def find_points(self):
             (R_inner[0], Z_inner[0]),
             (R_inner[-1], Z_inner[-1]),
             (R_outer[0], Z_outer[0]),
-            (R_outer[-1], Z_outer[-1])
+            (R_outer[-1], Z_outer[-1]),
         ]
         self.inner_leg_connection_points = inner_leg_connection_points
 
@@ -139,14 +147,14 @@ def find_points(self):
             R_outer = np.append(R_outer, R_outer[0])
             Z_outer = np.append(Z_outer, Z_outer[0])
         # add connections
-        inner_points = [[r, z, 'spline'] for r, z in zip(R_inner, Z_inner)]
-        outer_points = [[r, z, 'spline'] for r, z in zip(R_outer, Z_outer)]
+        inner_points = [[r, z, "spline"] for r, z in zip(R_inner, Z_inner)]
+        outer_points = [[r, z, "spline"] for r, z in zip(R_outer, Z_outer)]
         if self.with_inner_leg:
-            outer_points[-2][2] = 'straight'
-            inner_points[-2][2] = 'straight'
+            outer_points[-2][2] = "straight"
+            inner_points[-2][2] = "straight"
 
-        inner_points[-1][2] = 'straight'
-        outer_points[-1][2] = 'straight'
+        inner_points[-1][2] = "straight"
+        outer_points[-1][2] = "straight"
 
         points = inner_points + outer_points
 
@@ -156,11 +164,6 @@ def find_azimuth_placement_angle(self):
         """Calculates the azimuth placement angles based on the number of tf
         coils"""
 
-        angles = list(
-            np.linspace(
-                0,
-                360,
-                self.number_of_coils,
-                endpoint=False))
+        angles = list(np.linspace(0, 360, self.number_of_coils, endpoint=False))
 
         self.azimuth_placement_angle = angles
diff --git a/paramak/parametric_components/vacuum_vessel.py b/paramak/parametric_components/vacuum_vessel.py
index a5b08808a..f78a748c0 100644
--- a/paramak/parametric_components/vacuum_vessel.py
+++ b/paramak/parametric_components/vacuum_vessel.py
@@ -1,4 +1,3 @@
-
 from paramak import RotateStraightShape
 
 
@@ -11,19 +10,11 @@ class VacuumVessel(RotateStraightShape):
         thickness (float): thickness of the vessel
     """
 
-    def __init__(
-        self,
-        height,
-        inner_radius,
-        thickness,
-        **kwargs
-    ):
+    def __init__(self, height, inner_radius, thickness, **kwargs):
         self.height = height
         self.inner_radius = inner_radius
         self.thickness = thickness
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
     @property
     def height(self):
@@ -32,11 +23,11 @@ def height(self):
     @height.setter
     def height(self, value):
         if not isinstance(value, (float, int)):
-            raise ValueError('VacuumVessel.height must be a number. Not '
-                             f'{value}')
+            raise ValueError("VacuumVessel.height must be a number. Not " f"{value}")
         if value <= 0:
-            msg = ('VacuumVessel.height must be a positive number above 0. '
-                   f'Not {value}')
+            msg = (
+                "VacuumVessel.height must be a positive number above 0. " f"Not {value}"
+            )
             raise ValueError(msg)
         self._height = value
 
@@ -51,7 +42,7 @@ def inner_radius(self, value):
 
     def find_points(self):
         """Finds the XZ points joined by straight connections that describe the
-            2D profile of the vessel shape."""
+        2D profile of the vessel shape."""
         thickness = self.thickness
         inner_radius = self.inner_radius
         height = self.height
diff --git a/paramak/parametric_components/vacuum_vessel_inner_leg.py b/paramak/parametric_components/vacuum_vessel_inner_leg.py
index 8c8a47208..a3e08a409 100644
--- a/paramak/parametric_components/vacuum_vessel_inner_leg.py
+++ b/paramak/parametric_components/vacuum_vessel_inner_leg.py
@@ -1,7 +1,7 @@
-
 from typing import Optional
 
 import cadquery as cq
+
 from paramak import RotateStraightShape
 
 
@@ -21,15 +21,13 @@ def __init__(
         inner_radius: float,
         inner_leg_radius: float,
         thickness: float,
-        **kwargs
+        **kwargs,
     ):
         self.inner_height = inner_height
         self.inner_radius = inner_radius
         self.inner_leg_radius = inner_leg_radius
         self.thickness = thickness
-        super().__init__(
-            **kwargs
-        )
+        super().__init__(**kwargs)
 
     @property
     def inner_height(self):
@@ -39,10 +37,10 @@ def inner_height(self):
     def inner_height(self, value):
         if not isinstance(value, (float, int)):
             raise ValueError(
-                'VacuumVesselInnerLeg.inner_height must be a number. Not', value)
+                "VacuumVesselInnerLeg.inner_height must be a number. Not", value
+            )
         if value <= 0:
-            msg = (
-                f'VacuumVesselInnerLeg.inner_height must be a positive number above 0. Not {value}')
+            msg = f"VacuumVesselInnerLeg.inner_height must be a positive number above 0. Not {value}"
             raise ValueError(msg)
         self._inner_height = value
 
@@ -53,48 +51,52 @@ def inner_radius(self):
     @inner_radius.setter
     def inner_radius(self, value):
         if not isinstance(value, (float, int)):
-            msg = (
-                f'VacuumVesselInnerLeg.inner_radius must be a number. Not {value}')
+            msg = f"VacuumVesselInnerLeg.inner_radius must be a number. Not {value}"
             raise ValueError(msg)
         if value <= 0:
-            msg = (
-                f'VacuumVesselInnerLeg.inner_radius must be a positive number above 0. Not {value}')
+            msg = f"VacuumVesselInnerLeg.inner_radius must be a positive number above 0. Not {value}"
             raise ValueError(msg)
 
         self._inner_radius = value
 
     def find_points(self):
         """Finds the XZ points joined by straight connections that describe the
-            2D profile of the vessel shape."""
+        2D profile of the vessel shape."""
         thickness = self.thickness
         inner_radius = self.inner_radius
         inner_height = self.inner_height
         inner_leg_radius = self.inner_leg_radius
 
-        point_1 = (inner_leg_radius + 2 * thickness +
-                   inner_radius, thickness + (inner_height / 2.))
-        point_2 = (0, thickness + (inner_height / 2.))
-        point_3 = (0, -(thickness + (inner_height / 2.)))
-        point_4 = (inner_leg_radius + 2 * thickness +
-                   inner_radius, -(thickness + (inner_height / 2)))
-
-        point_5 = (
-            inner_leg_radius +
-            thickness +
-            inner_radius,
-            inner_height /
-            2)
+        point_1 = (
+            inner_leg_radius + 2 * thickness + inner_radius,
+            thickness + (inner_height / 2.0),
+        )
+        point_2 = (0, thickness + (inner_height / 2.0))
+        point_3 = (0, -(thickness + (inner_height / 2.0)))
+        point_4 = (
+            inner_leg_radius + 2 * thickness + inner_radius,
+            -(thickness + (inner_height / 2)),
+        )
+
+        point_5 = (inner_leg_radius + thickness + inner_radius, inner_height / 2)
         point_6 = (inner_leg_radius + thickness, inner_height / 2)
         point_7 = (inner_leg_radius + thickness, -inner_height / 2)
-        point_8 = (inner_leg_radius + thickness +
-                   inner_radius, -inner_height / 2)
+        point_8 = (inner_leg_radius + thickness + inner_radius, -inner_height / 2)
 
         points_9 = (inner_leg_radius, thickness + inner_height / 2)
         points_10 = (inner_leg_radius, -(thickness + inner_height / 2))
 
         self.points = [
-            point_1, point_2, point_3, point_4, point_5, point_6, point_7,
-            point_8, points_9, points_10
+            point_1,
+            point_2,
+            point_3,
+            point_4,
+            point_5,
+            point_6,
+            point_7,
+            point_8,
+            points_9,
+            points_10,
         ]
 
     def create_solid(self):
@@ -110,25 +112,17 @@ def create_solid(self):
         for point in self.points:
             local_points.append((point[0], point[1]))
 
-        big_wire = (
-            cq.Workplane(self.workplane)
-            .polyline(local_points[:4])
-        ).close()
+        big_wire = (cq.Workplane(self.workplane).polyline(local_points[:4])).close()
 
         small_wire = (
-            cq.Workplane(self.workplane)
-            .polyline(local_points[4:8])  # list of points has 10 entries
+            cq.Workplane(self.workplane).polyline(
+                local_points[4:8]
+            )  # list of points has 10 entries
         ).close()
 
         inner_wire = (
-            cq.Workplane(self.workplane)
-            .polyline(
-                [
-                    local_points[1],
-                    local_points[2],
-                    local_points[9],
-                    local_points[8]
-                ]
+            cq.Workplane(self.workplane).polyline(
+                [local_points[1], local_points[2], local_points[9], local_points[8]]
             )
         ).close()
 
diff --git a/paramak/parametric_reactors/ball_reactor.py b/paramak/parametric_reactors/ball_reactor.py
index c9f2306b9..d02ab455e 100644
--- a/paramak/parametric_reactors/ball_reactor.py
+++ b/paramak/parametric_reactors/ball_reactor.py
@@ -1,4 +1,3 @@
-
 import warnings
 from typing import List, Optional, Union
 
@@ -63,50 +62,48 @@ class BallReactor(paramak.Reactor):
     """
 
     def __init__(
-            self,
-            inner_bore_radial_thickness: float = 10.,
-            inboard_tf_leg_radial_thickness: float = 30.,
-            center_column_shield_radial_thickness: float = 60.,
-            divertor_radial_thickness: float = 150.,
-            inner_plasma_gap_radial_thickness: float = 30.,
-            plasma_radial_thickness: float = 300.,
-            outer_plasma_gap_radial_thickness: float = 30.,
-            plasma_gap_vertical_thickness: float = 50.,
-            firstwall_radial_thickness: float = 30.,
-            blanket_radial_thickness: float = 50.,
-            blanket_rear_wall_radial_thickness: float = 30.,
-            elongation: float = 2.,
-            triangularity: float = 0.55,
-            divertor_to_tf_gap_vertical_thickness: Optional[float] = 0,
-            number_of_tf_coils: Optional[int] = 12,
-            rear_blanket_to_tf_gap: Optional[float] = None,
-            pf_coil_radial_thicknesses: Optional[Union[float, List[float]]] = None,
-            pf_coil_vertical_thicknesses: Optional[Union[float, List[float]]] = None,
-            pf_coil_radial_position: Optional[Union[float, List[float]]] = None,
-            pf_coil_vertical_position: Optional[Union[float, List[float]]] = None,
-            pf_coil_case_thicknesses: Optional[Union[float, List[float]]] = 10,
-            outboard_tf_coil_radial_thickness: float = None,
-            outboard_tf_coil_poloidal_thickness: float = None,
-            divertor_position: Optional[str] = "both",
-            rotation_angle: Optional[str] = 360.0,
+        self,
+        inner_bore_radial_thickness: float = 10.0,
+        inboard_tf_leg_radial_thickness: float = 30.0,
+        center_column_shield_radial_thickness: float = 60.0,
+        divertor_radial_thickness: float = 150.0,
+        inner_plasma_gap_radial_thickness: float = 30.0,
+        plasma_radial_thickness: float = 300.0,
+        outer_plasma_gap_radial_thickness: float = 30.0,
+        plasma_gap_vertical_thickness: float = 50.0,
+        firstwall_radial_thickness: float = 30.0,
+        blanket_radial_thickness: float = 50.0,
+        blanket_rear_wall_radial_thickness: float = 30.0,
+        elongation: float = 2.0,
+        triangularity: float = 0.55,
+        divertor_to_tf_gap_vertical_thickness: Optional[float] = 0,
+        number_of_tf_coils: Optional[int] = 12,
+        rear_blanket_to_tf_gap: Optional[float] = None,
+        pf_coil_radial_thicknesses: Optional[Union[float, List[float]]] = None,
+        pf_coil_vertical_thicknesses: Optional[Union[float, List[float]]] = None,
+        pf_coil_radial_position: Optional[Union[float, List[float]]] = None,
+        pf_coil_vertical_position: Optional[Union[float, List[float]]] = None,
+        pf_coil_case_thicknesses: Optional[Union[float, List[float]]] = 10,
+        outboard_tf_coil_radial_thickness: float = None,
+        outboard_tf_coil_poloidal_thickness: float = None,
+        divertor_position: Optional[str] = "both",
+        rotation_angle: Optional[str] = 360.0,
     ):
 
         super().__init__([])
 
         self.inner_bore_radial_thickness = inner_bore_radial_thickness
         self.inboard_tf_leg_radial_thickness = inboard_tf_leg_radial_thickness
-        self.center_column_shield_radial_thickness = \
+        self.center_column_shield_radial_thickness = (
             center_column_shield_radial_thickness
+        )
         self.divertor_radial_thickness = divertor_radial_thickness
-        self.inner_plasma_gap_radial_thickness = \
-            inner_plasma_gap_radial_thickness
+        self.inner_plasma_gap_radial_thickness = inner_plasma_gap_radial_thickness
         self.plasma_radial_thickness = plasma_radial_thickness
-        self.outer_plasma_gap_radial_thickness = \
-            outer_plasma_gap_radial_thickness
+        self.outer_plasma_gap_radial_thickness = outer_plasma_gap_radial_thickness
         self.firstwall_radial_thickness = firstwall_radial_thickness
         self.blanket_radial_thickness = blanket_radial_thickness
-        self.blanket_rear_wall_radial_thickness = \
-            blanket_rear_wall_radial_thickness
+        self.blanket_rear_wall_radial_thickness = blanket_rear_wall_radial_thickness
 
         self.pf_coil_vertical_position = pf_coil_vertical_position
         self.pf_coil_radial_position = pf_coil_radial_position
@@ -115,15 +112,15 @@ def __init__(
         self.rear_blanket_to_tf_gap = rear_blanket_to_tf_gap
 
         self.pf_coil_case_thicknesses = pf_coil_case_thicknesses
-        self.outboard_tf_coil_radial_thickness = \
-            outboard_tf_coil_radial_thickness
-        self.outboard_tf_coil_poloidal_thickness = \
-            outboard_tf_coil_poloidal_thickness
+        self.outboard_tf_coil_radial_thickness = outboard_tf_coil_radial_thickness
+        self.outboard_tf_coil_poloidal_thickness = outboard_tf_coil_poloidal_thickness
         self.divertor_position = divertor_position
         self.rotation_angle = rotation_angle
 
         self.plasma_gap_vertical_thickness = plasma_gap_vertical_thickness
-        self.divertor_to_tf_gap_vertical_thickness = divertor_to_tf_gap_vertical_thickness
+        self.divertor_to_tf_gap_vertical_thickness = (
+            divertor_to_tf_gap_vertical_thickness
+        )
 
         self.elongation = elongation
         self.triangularity = triangularity
@@ -132,32 +129,32 @@ def __init__(
         self.rotation_angle = rotation_angle
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'inner_bore_radial_thickness',
-            'inboard_tf_leg_radial_thickness',
-            'center_column_shield_radial_thickness',
-            'divertor_radial_thickness',
-            'inner_plasma_gap_radial_thickness',
-            'plasma_radial_thickness',
-            'outer_plasma_gap_radial_thickness',
-            'firstwall_radial_thickness',
-            'blanket_radial_thickness',
-            'blanket_rear_wall_radial_thickness',
-            'elongation',
-            'triangularity',
-            'plasma_gap_vertical_thickness',
-            'divertor_to_tf_gap_vertical_thickness',
-            'number_of_tf_coils',
-            'rear_blanket_to_tf_gap',
-            'pf_coil_radial_thicknesses',
-            'pf_coil_vertical_thicknesses',
-            'pf_coil_radial_position',
-            'pf_coil_vertical_position',
-            'pf_coil_case_thicknesses',
-            'outboard_tf_coil_radial_thickness',
-            'outboard_tf_coil_poloidal_thickness',
-            'divertor_position',
-            'rotation_angle',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "inner_bore_radial_thickness",
+            "inboard_tf_leg_radial_thickness",
+            "center_column_shield_radial_thickness",
+            "divertor_radial_thickness",
+            "inner_plasma_gap_radial_thickness",
+            "plasma_radial_thickness",
+            "outer_plasma_gap_radial_thickness",
+            "firstwall_radial_thickness",
+            "blanket_radial_thickness",
+            "blanket_rear_wall_radial_thickness",
+            "elongation",
+            "triangularity",
+            "plasma_gap_vertical_thickness",
+            "divertor_to_tf_gap_vertical_thickness",
+            "number_of_tf_coils",
+            "rear_blanket_to_tf_gap",
+            "pf_coil_radial_thicknesses",
+            "pf_coil_vertical_thicknesses",
+            "pf_coil_radial_position",
+            "pf_coil_vertical_position",
+            "pf_coil_case_thicknesses",
+            "outboard_tf_coil_radial_thickness",
+            "outboard_tf_coil_poloidal_thickness",
+            "divertor_position",
+            "rotation_angle",
         ]
 
         # set by make_plasma
@@ -177,7 +174,7 @@ def rotation_angle(self, value):
             )
             warnings.warn(msg, UserWarning)
         elif value > 360:
-            raise ValueError('rotation_angle can not be larger than 360')
+            raise ValueError("rotation_angle can not be larger than 360")
         self._rotation_angle = value
 
     @property
@@ -273,8 +270,7 @@ def _make_plasma(self):
         # sets major radius and minor radius from equatorial_points to allow a
         # radial build. This helps avoid the plasma overlapping the center
         # column and other components
-        self.major_radius = (outer_equatorial_point +
-                             inner_equatorial_point) / 2
+        self.major_radius = (outer_equatorial_point + inner_equatorial_point) / 2
         self.minor_radius = self.major_radius - inner_equatorial_point
 
         plasma = paramak.Plasma(
@@ -300,11 +296,10 @@ def _make_radial_build(self):
 
         self._inboard_tf_coils_start_radius = self._inner_bore_end_radius
         self._inboard_tf_coils_end_radius = (
-            self._inboard_tf_coils_start_radius +
-            self.inboard_tf_leg_radial_thickness)
+            self._inboard_tf_coils_start_radius + self.inboard_tf_leg_radial_thickness
+        )
 
-        self._center_column_shield_start_radius = \
-            self._inboard_tf_coils_end_radius
+        self._center_column_shield_start_radius = self._inboard_tf_coils_end_radius
         self._center_column_shield_end_radius = (
             self._center_column_shield_start_radius
             + self.center_column_shield_radial_thickness
@@ -312,8 +307,8 @@ def _make_radial_build(self):
 
         self._divertor_start_radius = self._center_column_shield_end_radius
         self._divertor_end_radius = (
-            self._center_column_shield_end_radius +
-            self.divertor_radial_thickness)
+            self._center_column_shield_end_radius + self.divertor_radial_thickness
+        )
 
         self._firstwall_start_radius = (
             self._center_column_shield_end_radius
@@ -321,17 +316,20 @@ def _make_radial_build(self):
             + self.plasma_radial_thickness
             + self.outer_plasma_gap_radial_thickness
         )
-        self._firstwall_end_radius = self._firstwall_start_radius + \
-            self.firstwall_radial_thickness
+        self._firstwall_end_radius = (
+            self._firstwall_start_radius + self.firstwall_radial_thickness
+        )
 
         self._blanket_start_radius = self._firstwall_end_radius
-        self._blanket_end_radius = \
+        self._blanket_end_radius = (
             self._blanket_start_radius + self.blanket_radial_thickness
+        )
 
         self._blanket_rear_wall_start_radius = self._blanket_end_radius
         self._blanket_rear_wall_end_radius = (
-            self._blanket_rear_wall_start_radius +
-            self.blanket_rear_wall_radial_thickness)
+            self._blanket_rear_wall_start_radius
+            + self.blanket_rear_wall_radial_thickness
+        )
 
     def _make_vertical_build(self):
 
@@ -339,29 +337,37 @@ def _make_vertical_build(self):
         # in a similar manner to the radial build
 
         self._firstwall_start_height = (
-            self._plasma.high_point[1] +
-            self.plasma_gap_vertical_thickness)
-        self._firstwall_end_height = self._firstwall_start_height + \
-            self.firstwall_radial_thickness
+            self._plasma.high_point[1] + self.plasma_gap_vertical_thickness
+        )
+        self._firstwall_end_height = (
+            self._firstwall_start_height + self.firstwall_radial_thickness
+        )
 
         self._blanket_start_height = self._firstwall_end_height
-        self._blanket_end_height = self._blanket_start_height + self.blanket_radial_thickness
+        self._blanket_end_height = (
+            self._blanket_start_height + self.blanket_radial_thickness
+        )
 
         self._blanket_rear_wall_start_height = self._blanket_end_height
-        self._blanket_rear_wall_end_height = self._blanket_rear_wall_start_height + \
-            self.blanket_rear_wall_radial_thickness
+        self._blanket_rear_wall_end_height = (
+            self._blanket_rear_wall_start_height
+            + self.blanket_rear_wall_radial_thickness
+        )
 
-        self._tf_coil_start_height = self._blanket_rear_wall_end_height + \
-            self.divertor_to_tf_gap_vertical_thickness
+        self._tf_coil_start_height = (
+            self._blanket_rear_wall_end_height
+            + self.divertor_to_tf_gap_vertical_thickness
+        )
 
         self._center_column_shield_height = self._blanket_rear_wall_end_height * 2
 
         if self.rear_blanket_to_tf_gap is not None:
-            self._tf_coil_start_radius = self._blanket_rear_wall_end_radius + \
-                self.rear_blanket_to_tf_gap
+            self._tf_coil_start_radius = (
+                self._blanket_rear_wall_end_radius + self.rear_blanket_to_tf_gap
+            )
             self._tf_coil_end_radius = (
-                self._tf_coil_start_radius +
-                self.outboard_tf_coil_radial_thickness)
+                self._tf_coil_start_radius + self.outboard_tf_coil_radial_thickness
+            )
 
     def _make_inboard_tf_coils(self):
 
@@ -371,7 +377,7 @@ def _make_inboard_tf_coils(self):
             outer_radius=self._inboard_tf_coils_end_radius,
             rotation_angle=self.rotation_angle,
             name="inboard_tf_coils",
-            color=(0, 0, 1)
+            color=(0, 0, 1),
         )
         return self._inboard_tf_coils
 
@@ -382,7 +388,7 @@ def _make_center_column_shield(self):
             inner_radius=self._center_column_shield_start_radius,
             outer_radius=self._center_column_shield_end_radius,
             rotation_angle=self.rotation_angle,
-            color=(0., 0.333, 0.),
+            color=(0.0, 0.333, 0.0),
             name="center_column_shield",
         )
         return self._center_column_shield
@@ -394,7 +400,7 @@ def _make_blankets_layers(self):
             self.plasma_gap_vertical_thickness,
             self.outer_plasma_gap_radial_thickness,
             self.plasma_gap_vertical_thickness,
-            self.major_radius - self.minor_radius
+            self.major_radius - self.minor_radius,
         ]
 
         self._center_column_cutter = paramak.CenterColumnShieldCylinder(
@@ -403,7 +409,7 @@ def _make_blankets_layers(self):
             inner_radius=0,
             outer_radius=self._center_column_shield_end_radius,
             rotation_angle=360,
-            color=(0., 0., 1.)
+            color=(0.0, 0.0, 1.0),
         )
 
         self._firstwall = paramak.BlanketFP(
@@ -414,33 +420,36 @@ def _make_blankets_layers(self):
             stop_angle=180,
             rotation_angle=self.rotation_angle,
             color=(0.5, 0.5, 0.5),
-            name='firstwall',
-            cut=[self._center_column_cutter]
+            name="firstwall",
+            cut=[self._center_column_cutter],
         )
 
         self._blanket = paramak.BlanketFP(
             plasma=self._plasma,
             thickness=self.blanket_radial_thickness,
-            offset_from_plasma=[e + self.firstwall_radial_thickness
-                                for e in offset_from_plasma],
+            offset_from_plasma=[
+                e + self.firstwall_radial_thickness for e in offset_from_plasma
+            ],
             start_angle=-180,
             stop_angle=180,
             rotation_angle=self.rotation_angle,
-            color=(0., 1., 0.498),
-            name='blanket',
-            cut=[self._center_column_cutter])
+            color=(0.0, 1.0, 0.498),
+            name="blanket",
+            cut=[self._center_column_cutter],
+        )
 
         self._blanket_rear_wall = paramak.BlanketFP(
             plasma=self._plasma,
             thickness=self.blanket_rear_wall_radial_thickness,
-            offset_from_plasma=[e + self.firstwall_radial_thickness
-                                + self.blanket_radial_thickness
-                                for e in offset_from_plasma],
+            offset_from_plasma=[
+                e + self.firstwall_radial_thickness + self.blanket_radial_thickness
+                for e in offset_from_plasma
+            ],
             start_angle=-180,
             stop_angle=180,
             rotation_angle=self.rotation_angle,
-            color=(0., 1., 1.),
-            name='blanket_rear_wall',
+            color=(0.0, 1.0, 1.0),
+            name="blanket_rear_wall",
             cut=[self._center_column_cutter],
         )
 
@@ -453,15 +462,15 @@ def _make_divertor(self):
             self.plasma_gap_vertical_thickness,
             self.outer_plasma_gap_radial_thickness,
             self.plasma_gap_vertical_thickness,
-            self.major_radius - self.minor_radius
+            self.major_radius - self.minor_radius,
         ]
 
         # used as an intersect when making the divertor
         self._blanket_fw_rear_wall_envelope = paramak.BlanketFP(
             plasma=self._plasma,
-            thickness=self.firstwall_radial_thickness +
-            self.blanket_radial_thickness +
-            self.blanket_rear_wall_radial_thickness,
+            thickness=self.firstwall_radial_thickness
+            + self.blanket_radial_thickness
+            + self.blanket_rear_wall_radial_thickness,
             offset_from_plasma=offset_from_plasma,
             start_angle=-180,
             stop_angle=180,
@@ -482,34 +491,36 @@ def _make_divertor(self):
                 (self._divertor_start_radius, divertor_height_bottom),
                 (self._divertor_end_radius, divertor_height_bottom),
                 (self._divertor_end_radius, divertor_height_top),
-                (self._divertor_start_radius, divertor_height_top)
+                (self._divertor_start_radius, divertor_height_top),
             ],
             intersect=self._blanket_fw_rear_wall_envelope,
             name="divertor",
-            color=(1., 0.667, 0.),
-            rotation_angle=self.rotation_angle
+            color=(1.0, 0.667, 0.0),
+            rotation_angle=self.rotation_angle,
         )
 
-        for component in [
-                self._firstwall,
-                self._blanket,
-                self._blanket_rear_wall]:
+        for component in [self._firstwall, self._blanket, self._blanket_rear_wall]:
             component.cut.append(self._divertor)
 
         return self._divertor
 
     def _make_pf_coils(self):
-        if None not in [self.pf_coil_vertical_thicknesses,
-                        self.pf_coil_radial_thicknesses,
-                        self.pf_coil_vertical_position,
-                        self.pf_coil_radial_position]:
+        if None not in [
+            self.pf_coil_vertical_thicknesses,
+            self.pf_coil_radial_thicknesses,
+            self.pf_coil_vertical_position,
+            self.pf_coil_radial_position,
+        ]:
             list_of_components = []
 
             # TODO make use of counter in the name attribute
 
             center_points = [
-                (x, y) for x, y in zip(
-                    self.pf_coil_radial_position, self.pf_coil_vertical_position)]
+                (x, y)
+                for x, y in zip(
+                    self.pf_coil_radial_position, self.pf_coil_vertical_position
+                )
+            ]
 
             self._pf_coils = self._pf_coil = paramak.PoloidalFieldCoilSet(
                 heights=self.pf_coil_vertical_thicknesses,
@@ -532,32 +543,38 @@ def _make_pf_coils(self):
             return list_of_components
         else:
             print(
-                'pf_coil_vertical_thicknesses, pf_coil_radial_thicknesses, '
-                'pf_coil_radial_position, pf_coil_vertical_position not '
-                'so not making pf coils')
+                "pf_coil_vertical_thicknesses, pf_coil_radial_thicknesses, "
+                "pf_coil_radial_position, pf_coil_vertical_position not "
+                "so not making pf coils"
+            )
             return None
 
     def _make_tf_coils(self):
         comp = []
         # checks that all the required information has been input by the user
-        if None not in [
+        if (
+            None
+            not in [
                 self.rear_blanket_to_tf_gap,
                 self.outboard_tf_coil_radial_thickness,
                 self.outboard_tf_coil_poloidal_thickness,
-                self.number_of_tf_coils] and self.number_of_tf_coils > 1:
+                self.number_of_tf_coils,
+            ]
+            and self.number_of_tf_coils > 1
+        ):
 
             self._tf_coil = paramak.ToroidalFieldCoilRectangle(
                 with_inner_leg=False,
                 horizontal_start_point=(
                     self._inboard_tf_coils_start_radius,
-                    self._tf_coil_start_height),
-                vertical_mid_point=(
-                    self._tf_coil_start_radius, 0),
+                    self._tf_coil_start_height,
+                ),
+                vertical_mid_point=(self._tf_coil_start_radius, 0),
                 thickness=self.outboard_tf_coil_radial_thickness,
                 number_of_coils=self.number_of_tf_coils,
                 distance=self.outboard_tf_coil_poloidal_thickness,
                 name="tf_coil",
-                rotation_angle=self.rotation_angle
+                rotation_angle=self.rotation_angle,
             )
             comp = [self._tf_coil]
         return comp
diff --git a/paramak/parametric_reactors/center_column_study_reactor.py b/paramak/parametric_reactors/center_column_study_reactor.py
index 2e7a65e39..50059146f 100644
--- a/paramak/parametric_reactors/center_column_study_reactor.py
+++ b/paramak/parametric_reactors/center_column_study_reactor.py
@@ -1,5 +1,5 @@
-
 import warnings
+from typing import List
 
 import paramak
 
@@ -46,15 +46,15 @@ class CenterColumnStudyReactor(paramak.Reactor):
     def __init__(
         self,
         inner_bore_radial_thickness: float = 20,
-        inboard_tf_leg_radial_thickness: float = 50.,
-        center_column_shield_radial_thickness_mid: float = 50.,
-        center_column_shield_radial_thickness_upper: float = 100.,
-        inboard_firstwall_radial_thickness: float = 20.,
-        divertor_radial_thickness: float = 100.,
-        inner_plasma_gap_radial_thickness: float = 80.,
-        plasma_radial_thickness: float = 200.,
+        inboard_tf_leg_radial_thickness: float = 50.0,
+        center_column_shield_radial_thickness_mid: float = 50.0,
+        center_column_shield_radial_thickness_upper: float = 100.0,
+        inboard_firstwall_radial_thickness: float = 20.0,
+        divertor_radial_thickness: float = 100.0,
+        inner_plasma_gap_radial_thickness: float = 80.0,
+        plasma_radial_thickness: float = 200.0,
         outer_plasma_gap_radial_thickness: float = 90,
-        center_column_arc_vertical_thickness: float = 520.,
+        center_column_arc_vertical_thickness: float = 520.0,
         elongation: float = 2.3,
         triangularity: float = 0.45,
         plasma_gap_vertical_thickness: float = 40,
@@ -65,41 +65,39 @@ def __init__(
 
         self.inner_bore_radial_thickness = inner_bore_radial_thickness
         self.inboard_tf_leg_radial_thickness = inboard_tf_leg_radial_thickness
-        self.center_column_shield_radial_thickness_mid = \
+        self.center_column_shield_radial_thickness_mid = (
             center_column_shield_radial_thickness_mid
-        self.center_column_shield_radial_thickness_upper = \
+        )
+        self.center_column_shield_radial_thickness_upper = (
             center_column_shield_radial_thickness_upper
-        self.inboard_firstwall_radial_thickness = \
-            inboard_firstwall_radial_thickness
+        )
+        self.inboard_firstwall_radial_thickness = inboard_firstwall_radial_thickness
         self.divertor_radial_thickness = divertor_radial_thickness
-        self.inner_plasma_gap_radial_thickness = \
-            inner_plasma_gap_radial_thickness
+        self.inner_plasma_gap_radial_thickness = inner_plasma_gap_radial_thickness
         self.plasma_radial_thickness = plasma_radial_thickness
-        self.outer_plasma_gap_radial_thickness = \
-            outer_plasma_gap_radial_thickness
+        self.outer_plasma_gap_radial_thickness = outer_plasma_gap_radial_thickness
         self.plasma_gap_vertical_thickness = plasma_gap_vertical_thickness
-        self.center_column_arc_vertical_thickness = \
-            center_column_arc_vertical_thickness
+        self.center_column_arc_vertical_thickness = center_column_arc_vertical_thickness
         self.rotation_angle = rotation_angle
         self.elongation = elongation
         self.triangularity = triangularity
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'inner_bore_radial_thickness',
-            'inboard_tf_leg_radial_thickness',
-            'center_column_shield_radial_thickness_mid',
-            'center_column_shield_radial_thickness_upper',
-            'inboard_firstwall_radial_thickness',
-            'divertor_radial_thickness',
-            'inner_plasma_gap_radial_thickness',
-            'plasma_radial_thickness',
-            'outer_plasma_gap_radial_thickness',
-            'center_column_arc_vertical_thickness',
-            'elongation',
-            'triangularity',
-            'plasma_gap_vertical_thickness',
-            'rotation_angle',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "inner_bore_radial_thickness",
+            "inboard_tf_leg_radial_thickness",
+            "center_column_shield_radial_thickness_mid",
+            "center_column_shield_radial_thickness_upper",
+            "inboard_firstwall_radial_thickness",
+            "divertor_radial_thickness",
+            "inner_plasma_gap_radial_thickness",
+            "plasma_radial_thickness",
+            "outer_plasma_gap_radial_thickness",
+            "center_column_arc_vertical_thickness",
+            "elongation",
+            "triangularity",
+            "plasma_gap_vertical_thickness",
+            "rotation_angle",
         ]
 
         # set by make_plasma
@@ -109,8 +107,8 @@ def __init__(
     def create_solids(self):
         """Creates a 3d solids for each component.
 
-           Returns:
-              A list of CadQuery solids: A list of 3D solid volumes
+        Returns:
+           A list of CadQuery solids: A list of 3D solid volumes
 
         """
         shapes_and_components = []
@@ -130,8 +128,10 @@ def create_solids(self):
     def _rotation_angle_check(self):
 
         if self.rotation_angle == 360:
-            msg = "360 degree rotation may result " + \
-                "in a Standard_ConstructionError or AttributeError"
+            msg = (
+                "360 degree rotation may result "
+                + "in a Standard_ConstructionError or AttributeError"
+            )
             warnings.warn(msg, UserWarning)
 
     def _make_plasma(self):
@@ -146,10 +146,8 @@ def _make_plasma(self):
             + self.center_column_shield_radial_thickness_mid
             + self.inner_plasma_gap_radial_thickness
         )
-        outer_equatorial_point = \
-            inner_equatorial_point + self.plasma_radial_thickness
-        self.major_radius = \
-            (outer_equatorial_point + inner_equatorial_point) / 2
+        outer_equatorial_point = inner_equatorial_point + self.plasma_radial_thickness
+        self.major_radius = (outer_equatorial_point + inner_equatorial_point) / 2
         self.minor_radius = self.major_radius - inner_equatorial_point
 
         plasma = paramak.Plasma(
@@ -169,54 +167,59 @@ def _make_radial_build(self):
         # another starts
 
         self._inner_bore_start_radius = 0
-        self._inner_bore_end_radius = self._inner_bore_start_radius + \
-            self.inner_bore_radial_thickness
+        self._inner_bore_end_radius = (
+            self._inner_bore_start_radius + self.inner_bore_radial_thickness
+        )
 
         self._inboard_tf_coils_start_radius = self._inner_bore_end_radius
-        self._inboard_tf_coils_end_radius = \
-            self._inboard_tf_coils_start_radius + \
-            self.inboard_tf_leg_radial_thickness
-
-        self._center_column_shield_start_radius = \
-            self._inboard_tf_coils_end_radius
-        self._center_column_shield_end_radius_upper = \
-            self._center_column_shield_start_radius + \
-            self.center_column_shield_radial_thickness_upper
-        self._center_column_shield_end_radius_mid = \
-            self._center_column_shield_start_radius + \
-            self.center_column_shield_radial_thickness_mid
-
-        self._inboard_firstwall_start_radius = \
+        self._inboard_tf_coils_end_radius = (
+            self._inboard_tf_coils_start_radius + self.inboard_tf_leg_radial_thickness
+        )
+
+        self._center_column_shield_start_radius = self._inboard_tf_coils_end_radius
+        self._center_column_shield_end_radius_upper = (
+            self._center_column_shield_start_radius
+            + self.center_column_shield_radial_thickness_upper
+        )
+        self._center_column_shield_end_radius_mid = (
+            self._center_column_shield_start_radius
+            + self.center_column_shield_radial_thickness_mid
+        )
+
+        self._inboard_firstwall_start_radius = (
             self._center_column_shield_end_radius_upper
-        self._inboard_firstwall_end_radius = \
-            self._inboard_firstwall_start_radius + \
-            self.inboard_firstwall_radial_thickness
+        )
+        self._inboard_firstwall_end_radius = (
+            self._inboard_firstwall_start_radius
+            + self.inboard_firstwall_radial_thickness
+        )
 
         self._divertor_start_radius = self._inboard_firstwall_end_radius
-        self._divertor_end_radius = self._divertor_start_radius + \
-            self.divertor_radial_thickness
+        self._divertor_end_radius = (
+            self._divertor_start_radius + self.divertor_radial_thickness
+        )
 
-        self._inner_plasma_gap_start_radius = \
-            self._center_column_shield_end_radius_mid + \
-            self.inboard_firstwall_radial_thickness
+        self._inner_plasma_gap_start_radius = (
+            self._center_column_shield_end_radius_mid
+            + self.inboard_firstwall_radial_thickness
+        )
 
-        self._inner_plasma_gap_end_radius = \
-            self._inner_plasma_gap_start_radius + \
-            self.inner_plasma_gap_radial_thickness
+        self._inner_plasma_gap_end_radius = (
+            self._inner_plasma_gap_start_radius + self.inner_plasma_gap_radial_thickness
+        )
 
         self._plasma_start_radius = self._inner_plasma_gap_end_radius
-        self._plasma_end_radius = \
-            self._plasma_start_radius + \
-            self.plasma_radial_thickness
+        self._plasma_end_radius = (
+            self._plasma_start_radius + self.plasma_radial_thickness
+        )
 
         self._outer_plasma_gap_start_radius = self._plasma_end_radius
-        self._outer_plasma_gap_end_radius = \
-            self._outer_plasma_gap_start_radius + \
-            self.outer_plasma_gap_radial_thickness
+        self._outer_plasma_gap_end_radius = (
+            self._outer_plasma_gap_start_radius + self.outer_plasma_gap_radial_thickness
+        )
 
         self._outboard_blanket_start_radius = self._outer_plasma_gap_end_radius
-        self._outboard_blanket_end_radius = \
-            self._outboard_blanket_start_radius + 100.
+        self._outboard_blanket_end_radius = self._outboard_blanket_start_radius + 100.0
 
     def _make_vertical_build(self):
 
@@ -224,12 +227,13 @@ def _make_vertical_build(self):
         # a similar manner to the radial build
 
         self._plasma_to_blanket_gap_start_height = self._plasma.high_point[1]
-        self._plasma_to_blanket_gap_end_height = \
-            self._plasma_to_blanket_gap_start_height + \
-            self.plasma_gap_vertical_thickness
+        self._plasma_to_blanket_gap_end_height = (
+            self._plasma_to_blanket_gap_start_height
+            + self.plasma_gap_vertical_thickness
+        )
 
         self._blanket_start_height = self._plasma_to_blanket_gap_end_height
-        self._blanket_end_height = self._blanket_start_height + 100.
+        self._blanket_end_height = self._blanket_start_height + 100.0
 
         self._center_column_shield_end_height = self._blanket_end_height
         self._inboard_firstwall_end_height = self._blanket_end_height
@@ -242,20 +246,20 @@ def _make_inboard_tf_coils(self):
             outer_radius=self._inboard_tf_coils_end_radius,
             rotation_angle=self.rotation_angle,
             name="inboard_tf_coils",
-            color=(0., 0., 1.)
+            color=(0.0, 0.0, 1.0),
         )
         return self._inboard_tf_coils
 
     def _make_center_column_shield(self):
 
-        self._center_column_shield = \
-            paramak.CenterColumnShieldFlatTopHyperbola(
-                height=self._center_column_shield_end_height * 2.,
-                arc_height=self.center_column_arc_vertical_thickness,
-                inner_radius=self._center_column_shield_start_radius,
-                mid_radius=self._center_column_shield_end_radius_mid,
-                outer_radius=self._center_column_shield_end_radius_upper,
-                rotation_angle=self.rotation_angle)
+        self._center_column_shield = paramak.CenterColumnShieldFlatTopHyperbola(
+            height=self._center_column_shield_end_height * 2.0,
+            arc_height=self.center_column_arc_vertical_thickness,
+            inner_radius=self._center_column_shield_start_radius,
+            mid_radius=self._center_column_shield_end_radius_mid,
+            outer_radius=self._center_column_shield_end_radius_upper,
+            rotation_angle=self.rotation_angle,
+        )
         return self._center_column_shield
 
     def _make_inboard_firstwall(self):
@@ -263,7 +267,8 @@ def _make_inboard_firstwall(self):
         self._inboard_firstwall = paramak.InboardFirstwallFCCS(
             central_column_shield=self._center_column_shield,
             thickness=self.inboard_firstwall_radial_thickness,
-            rotation_angle=self.rotation_angle)
+            rotation_angle=self.rotation_angle,
+        )
         return self._inboard_firstwall
 
     def _make_outboard_blanket(self):
@@ -273,51 +278,53 @@ def _make_outboard_blanket(self):
             height=self._inboard_firstwall_end_height * 2.5,
             inner_radius=0,
             outer_radius=self._inboard_firstwall_end_radius,
-            rotation_angle=self.rotation_angle
+            rotation_angle=self.rotation_angle,
         )
 
         self._blanket = paramak.BlanketFP(
             plasma=self._plasma,
-            thickness=100.,
+            thickness=100.0,
             offset_from_plasma=[
                 self.inner_plasma_gap_radial_thickness,
                 self.plasma_gap_vertical_thickness,
                 self.outer_plasma_gap_radial_thickness,
                 self.plasma_gap_vertical_thickness,
-                self.inner_plasma_gap_radial_thickness],
+                self.inner_plasma_gap_radial_thickness,
+            ],
             start_angle=-180,
             stop_angle=180,
-            color=(0., 1., 0.498),
+            color=(0.0, 1.0, 0.498),
             rotation_angle=self.rotation_angle,
-            cut=[self._center_column_cutter]
+            cut=[self._center_column_cutter],
         )
         return self._blanket
 
     def _make_divertor(self):
         self._blanket_enveloppe = paramak.BlanketFP(
             plasma=self._plasma,
-            thickness=100.,
+            thickness=100.0,
             offset_from_plasma=[
                 self.inner_plasma_gap_radial_thickness,
                 self.plasma_gap_vertical_thickness,
                 self.outer_plasma_gap_radial_thickness,
                 self.plasma_gap_vertical_thickness,
-                self.inner_plasma_gap_radial_thickness],
+                self.inner_plasma_gap_radial_thickness,
+            ],
             start_angle=-180,
             stop_angle=180,
             rotation_angle=self.rotation_angle,
-            cut=[self._center_column_cutter]
+            cut=[self._center_column_cutter],
         )
 
         self._divertor = paramak.CenterColumnShieldCylinder(
-            height=self._center_column_shield_end_height *
-            2.5,  # extra 0.5 to ensure overlap
+            height=self._center_column_shield_end_height
+            * 2.5,  # extra 0.5 to ensure overlap
             inner_radius=self._divertor_start_radius,
             outer_radius=self._divertor_end_radius,
             rotation_angle=self.rotation_angle,
             name="divertor",
             intersect=self._blanket_enveloppe,
-            color=(1., 0.667, 0.),
+            color=(1.0, 0.667, 0.0),
         )
         self._blanket.cut.append(self._divertor)
         return self._divertor
diff --git a/paramak/parametric_reactors/eu_demo_2015_reactor.py b/paramak/parametric_reactors/eu_demo_2015_reactor.py
index 8e3a7de3d..68f59cc8f 100644
--- a/paramak/parametric_reactors/eu_demo_2015_reactor.py
+++ b/paramak/parametric_reactors/eu_demo_2015_reactor.py
@@ -1,6 +1,6 @@
+import numpy as np
 
 import paramak
-import numpy as np
 
 
 class EuDemoFrom2015PaperDiagram(paramak.Reactor):
@@ -18,7 +18,7 @@ class EuDemoFrom2015PaperDiagram(paramak.Reactor):
 
     def __init__(
         self,
-        rotation_angle: float = 360.,
+        rotation_angle: float = 360.0,
         number_of_tf_coils: int = 16,
     ):
 
@@ -29,8 +29,8 @@ def __init__(
 
         # adds self.input_variable_names from the Reactor class
         self.input_variable_names = self.input_variable_names + [
-            'number_of_tf_coils',
-            'rotation_angle',
+            "number_of_tf_coils",
+            "rotation_angle",
         ]
 
     def create_tf_coils(self, vac_vessel_inner, vac_vessel) -> list:
@@ -67,7 +67,6 @@ def create_tf_coils(self, vac_vessel_inner, vac_vessel) -> list:
                 (1472.0427244009875, 273.43725790865426, "spline"),
                 (1486.7783924978662, 209.78591729219943, "spline"),
                 (1498.1749436860923, 130.9324032157914, "spline"),
-
                 (1506.997123663055, -64.35717673922625, "spline"),
                 (1499.4815546503473, -158.26084228529953, "spline"),
                 (1489.8271514144617, -227.50802018403465, "spline"),
@@ -83,9 +82,8 @@ def create_tf_coils(self, vac_vessel_inner, vac_vessel) -> list:
                 (1088.9153538821483, -828.8191952873351, "spline"),
                 (1025.9076696058407, -851.7220231166343, "spline"),
                 (962.899985329533, -866.3620671041153, "spline"),
-
-                (805.5787769784172, -875., "straight"),
-                (377.70287769784176, -875., "straight"),
+                (805.5787769784172, -875.0, "straight"),
+                (377.70287769784176, -875.0, "straight"),
                 (375.4508992805756, 755, "straight"),
             ],
             distance=200,
@@ -93,9 +91,10 @@ def create_tf_coils(self, vac_vessel_inner, vac_vessel) -> list:
             # azimuth placement angle can't start at
             # zero nor end at 360 until #757 is solved
             azimuth_placement_angle=np.linspace(
-                0 + 20, 360 + 20, self.number_of_tf_coils),
+                0 + 20, 360 + 20, self.number_of_tf_coils
+            ),
             rotation_angle=self.rotation_angle,
-            color=(1., 1., 0.498),
+            color=(1.0, 1.0, 0.498),
         )
 
         return [tf_coil_casing]
@@ -136,7 +135,7 @@ def create_vessel_components(self) -> list:
                 (945.6554596218276, -418.4558632109989, "straight"),
             ],
             rotation_angle=self.rotation_angle,
-            color=(0., 1., 0.498),
+            color=(0.0, 1.0, 0.498),
         )
 
         # SN Divertor
@@ -169,7 +168,7 @@ def create_vessel_components(self) -> list:
                 (584.5345245889013, -415.60146955751554, "straight"),
             ],
             rotation_angle=self.rotation_angle,
-            color=(1., 0.667, 0.),
+            color=(1.0, 0.667, 0.0),
         )
 
         # Vacuum vessel
@@ -281,7 +280,7 @@ def create_vessel_components(self) -> list:
             ],
             cut=vac_vessel_inner,  # hollow shape
             rotation_angle=self.rotation_angle,
-            color=(0., 1., 1.),
+            color=(0.0, 1.0, 1.0),
         )
 
         return [divertor, blanket, vac_vessel, vac_vessel_inner]
@@ -325,7 +324,7 @@ def create_pf_coils(self) -> list:
                 1628 - 1526,
                 1598 - 1503,
                 1439 - 1360,
-                684 - 563
+                684 - 563,
             ],
             heights=[
                 803 - 599,
@@ -333,7 +332,7 @@ def create_pf_coils(self) -> list:
                 1628 - 1526,
                 1598 - 1503,
                 1439 - 1360,
-                684 - 563
+                684 - 563,
             ],
             rotation_angle=self.rotation_angle,
         )
@@ -388,8 +387,14 @@ def create_pf_coils(self) -> list:
             rotation_angle=self.rotation_angle,
         )
 
-        return [outboard_pf_coils, pf_coils_1, pf_coils_2, pf_coils_3,
-                pf_coils_4, pf_coils_5]
+        return [
+            outboard_pf_coils,
+            pf_coils_1,
+            pf_coils_2,
+            pf_coils_3,
+            pf_coils_4,
+            pf_coils_5,
+        ]
 
     def create_solids(self):
         """Creates a 3d solids for each component.
@@ -403,8 +408,7 @@ def create_solids(self):
         vessel = self.create_vessel_components()
         tf_coil_casing = self.create_tf_coils(vessel[-1], vessel[-2])
 
-        shapes_and_components = plasma + \
-            pf_coils + vessel[:-1] + tf_coil_casing
+        shapes_and_components = plasma + pf_coils + vessel[:-1] + tf_coil_casing
         self.shapes_and_components = shapes_and_components
 
         return shapes_and_components
diff --git a/paramak/parametric_reactors/flf_system_code_reactor.py b/paramak/parametric_reactors/flf_system_code_reactor.py
index c13aba1d8..08a371ca4 100644
--- a/paramak/parametric_reactors/flf_system_code_reactor.py
+++ b/paramak/parametric_reactors/flf_system_code_reactor.py
@@ -1,5 +1,4 @@
-
-from typing import List, Optional, Union
+from typing import List, Optional
 
 import paramak
 
@@ -21,10 +20,10 @@ class FlfSystemCodeReactor(paramak.Reactor):
         blanket_vv_gap: The radial distance between the outer edge of the
             blanket and the inner edge of the vaccum vessel (cm).
         upper_vv_thickness: The thickness (z axis direction) of the
-            the upper section of vaccum vessel (cm).
+            upper section of vaccum vessel (cm).
         vv_thickness: The radial thickness of the vaccum vessel (cm)
         lower_vv_thickness: The thickness (z axis direction) of the
-            the lower section of vaccum vessel (cm).
+            lower section of vaccum vessel (cm).
         rotation_angle: The angle of the sector simulated. Set to 360 for
             simulations and less when creating models for visualization.
     Returns:
@@ -33,15 +32,15 @@ class FlfSystemCodeReactor(paramak.Reactor):
 
     def __init__(
         self,
-        inner_blanket_radius: Optional[float] = 100.,
-        blanket_thickness: Optional[float] = 70.,
-        blanket_height: Optional[float] = 500.,
-        lower_blanket_thickness: Optional[float] = 50.,
-        upper_blanket_thickness: Optional[float] = 40.,
-        blanket_vv_gap: Optional[float] = 20.,
-        upper_vv_thickness: Optional[float] = 10.,
-        vv_thickness: Optional[float] = 10.,
-        lower_vv_thickness: Optional[float] = 10.,
+        inner_blanket_radius: Optional[float] = 100.0,
+        blanket_thickness: Optional[float] = 70.0,
+        blanket_height: Optional[float] = 500.0,
+        lower_blanket_thickness: Optional[float] = 50.0,
+        upper_blanket_thickness: Optional[float] = 40.0,
+        blanket_vv_gap: Optional[float] = 20.0,
+        upper_vv_thickness: Optional[float] = 10.0,
+        vv_thickness: Optional[float] = 10.0,
+        lower_vv_thickness: Optional[float] = 10.0,
         rotation_angle: Optional[float] = 360,
     ):
 
@@ -59,17 +58,17 @@ def __init__(
         self.lower_vv_thickness = lower_vv_thickness
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'inner_blanket_radius',
-            'blanket_thickness',
-            'blanket_height',
-            'lower_blanket_thickness',
-            'upper_blanket_thickness',
-            'blanket_vv_gap',
-            'upper_vv_thickness',
-            'vv_thickness',
-            'lower_vv_thickness',
-            'rotation_angle',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "inner_blanket_radius",
+            "blanket_thickness",
+            "blanket_height",
+            "lower_blanket_thickness",
+            "upper_blanket_thickness",
+            "blanket_vv_gap",
+            "upper_vv_thickness",
+            "vv_thickness",
+            "lower_vv_thickness",
+            "rotation_angle",
         ]
 
     def create_solids(self):
@@ -77,30 +76,28 @@ def create_solids(self):
         self.shapes_and_components
         """
         inner_wall = (
-            self.inner_blanket_radius +
-            self.blanket_thickness +
-            self.blanket_vv_gap)
+            self.inner_blanket_radius + self.blanket_thickness + self.blanket_vv_gap
+        )
         lower_vv = paramak.RotateStraightShape(
             points=[
-                (inner_wall,
-                 (-self.blanket_height / 2.0) - self.lower_blanket_thickness,
-                 ),
-                (inner_wall,
-                 (-self.blanket_height / 2.0) - (
-                     self.lower_blanket_thickness + self.lower_vv_thickness),
-                 ),
-                (0,
-                 (-self.blanket_height / 2.0) - (
-                     self.lower_blanket_thickness + self.lower_vv_thickness),
-                 ),
-                (0,
-                 (-self.blanket_height / 2.0) - self.lower_blanket_thickness),
+                (
+                    inner_wall,
+                    (-self.blanket_height / 2.0) - self.lower_blanket_thickness,
+                ),
+                (
+                    inner_wall,
+                    (-self.blanket_height / 2.0)
+                    - (self.lower_blanket_thickness + self.lower_vv_thickness),
+                ),
+                (
+                    0,
+                    (-self.blanket_height / 2.0)
+                    - (self.lower_blanket_thickness + self.lower_vv_thickness),
+                ),
+                (0, (-self.blanket_height / 2.0) - self.lower_blanket_thickness),
             ],
             rotation_angle=self.rotation_angle,
-            color=(
-                0.5,
-                0.5,
-                0.5),
+            color=(0.5, 0.5, 0.5),
             name="lower_vacuum_vessel",
         )
 
diff --git a/paramak/parametric_reactors/iter_paper_2020.py b/paramak/parametric_reactors/iter_paper_2020.py
index 435c68056..621b5a1fe 100644
--- a/paramak/parametric_reactors/iter_paper_2020.py
+++ b/paramak/parametric_reactors/iter_paper_2020.py
@@ -1,6 +1,7 @@
+from typing import List
 
-import paramak
 import numpy as np
+import paramak
 
 
 class IterFrom2020PaperDiagram(paramak.Reactor):
@@ -17,7 +18,7 @@ class IterFrom2020PaperDiagram(paramak.Reactor):
 
     def __init__(
         self,
-        rotation_angle: float = 360.,
+        rotation_angle: float = 360.0,
         number_of_tf_coils: int = 18,
     ):
 
@@ -27,9 +28,9 @@ def __init__(
         self.number_of_tf_coils = number_of_tf_coils
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'number_of_tf_coils',
-            'rotation_angle',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "number_of_tf_coils",
+            "rotation_angle",
         ]
 
     def create_tf_coils(self) -> list:
@@ -117,7 +118,6 @@ def create_vessel_components(self) -> list:
                 (510.2245275810152, 564.0927634387052),
                 (545.6438096482208, 565.1200145185009),
                 (565.832800426528, 563.1864687746993),
-
                 (580.9745435102584, 559.4390362932862),
                 (616.3052773722961, 548.4109567158157),
                 (651.6360112343338, 533.224020531035),
@@ -136,7 +136,6 @@ def create_vessel_components(self) -> list:
                 (962.8829523999035, 118.10702768634405),
                 (967.9302000944803, 80.39197257542594),
                 (968.7714080435763, 38.24754419835381),
-
                 (968.7714080435763, 25.77097437642317),
                 (964.5653682980957, -1.670738783514139),
                 (956.9944967562304, -29.93883090626548),
@@ -175,7 +174,6 @@ def create_vessel_components(self) -> list:
                 (327.770950832322, -137.06073162914538),
                 (327.770950832322, -102.12633612773948),
                 (327.770950832322, -67.19194062633369),
-
             ],
             cut=[vac_vessel_inner],  # to make a hollow shape
             rotation_angle=self.rotation_angle,
@@ -210,23 +208,27 @@ def create_pf_coils(self) -> list:
         """
 
         # from diagram
-        bot_lefts = np.array([
-            (345.5429497568881, -788.0537547271744),
-            (800.6482982171799, -703.3664235548353),
-            (1160.9400324149108, -272.69381415451096),
-            (1158.833063209076, 268.97622906537015),
-            (798.5413290113453, 621.6369529983793),
-            (345.5429497568881, 707.7795786061589),
-        ])
-
-        top_rights = np.array([
-            (511.99351701782825, -690.4038357644516),
-            (880.7131280388979, -611.8280659103187),
-            (1222.0421393841166, -162.37506753106413),
-            (1230.4700162074555, 379.2780929227446),
-            (861.7504051863858, 681.9523230686117),
-            (446.677471636953, 803.4508373851974),
-        ])
+        bot_lefts = np.array(
+            [
+                (345.5429497568881, -788.0537547271744),
+                (800.6482982171799, -703.3664235548353),
+                (1160.9400324149108, -272.69381415451096),
+                (1158.833063209076, 268.97622906537015),
+                (798.5413290113453, 621.6369529983793),
+                (345.5429497568881, 707.7795786061589),
+            ]
+        )
+
+        top_rights = np.array(
+            [
+                (511.99351701782825, -690.4038357644516),
+                (880.7131280388979, -611.8280659103187),
+                (1222.0421393841166, -162.37506753106413),
+                (1230.4700162074555, 379.2780929227446),
+                (861.7504051863858, 681.9523230686117),
+                (446.677471636953, 803.4508373851974),
+            ]
+        )
 
         outboard_pf_coils = paramak.PoloidalFieldCoilSet(
             center_points=((bot_lefts + top_rights) / 2).tolist(),
@@ -297,8 +299,15 @@ def create_pf_coils(self) -> list:
             rotation_angle=self.rotation_angle,
         )
 
-        return [outboard_pf_coils, pf_coils_1, pf_coils_2, pf_coils_3,
-                pf_coils_4, pf_coils_5, pf_coils_6]
+        return [
+            outboard_pf_coils,
+            pf_coils_1,
+            pf_coils_2,
+            pf_coils_3,
+            pf_coils_4,
+            pf_coils_5,
+            pf_coils_6,
+        ]
 
     def create_solids(self):
         """Creates a 3d solids for each component.
@@ -312,8 +321,7 @@ def create_solids(self):
         tf_coil = self.create_tf_coils()
         vessel = self.create_vessel_components()
 
-        shapes_and_components = plasma + \
-            pf_coils + vessel[:-1] + tf_coil
+        shapes_and_components = plasma + pf_coils + vessel[:-1] + tf_coil
         self.shapes_and_components = shapes_and_components
 
         return shapes_and_components
diff --git a/paramak/parametric_reactors/segmented_blanket_ball_reactor.py b/paramak/parametric_reactors/segmented_blanket_ball_reactor.py
index b5968066d..54be01cd6 100644
--- a/paramak/parametric_reactors/segmented_blanket_ball_reactor.py
+++ b/paramak/parametric_reactors/segmented_blanket_ball_reactor.py
@@ -1,7 +1,8 @@
+from typing import List
 
-import paramak
-import numpy as np
 import cadquery as cq
+import numpy as np
+import paramak
 
 
 class SegmentedBlanketBallReactor(paramak.BallReactor):
@@ -21,11 +22,11 @@ class SegmentedBlanketBallReactor(paramak.BallReactor):
     """
 
     def __init__(
-            self,
-            gap_between_blankets: float = 15.,
-            number_of_blanket_segments: int = 12,
-            blanket_fillet_radius: float = 10.,
-            **kwargs
+        self,
+        gap_between_blankets: float = 15.0,
+        number_of_blanket_segments: int = 12,
+        blanket_fillet_radius: float = 10.0,
+        **kwargs
     ):
 
         self.gap_between_blankets = gap_between_blankets
@@ -35,10 +36,10 @@ def __init__(
         super().__init__(**kwargs)
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'gap_between_blankets',
-            'number_of_blanket_segments',
-            'blanket_fillet_radius'
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "gap_between_blankets",
+            "number_of_blanket_segments",
+            "blanket_fillet_radius",
         ]
 
     @property
@@ -53,8 +54,7 @@ def gap_between_blankets(self, value):
         if isinstance(value, (float, int)) and value > 0:
             self._gap_between_blankets = float(value)
         else:
-            raise ValueError(
-                "gap_between_blankets but be a positive value float")
+            raise ValueError("gap_between_blankets but be a positive value float")
 
     @property
     def number_of_blanket_segments(self):
@@ -67,21 +67,22 @@ def number_of_blanket_segments(self, value):
         if isinstance(value, int) and value > 2:
             self._number_of_blanket_segments = value
         else:
-            raise ValueError(
-                "number_of_blanket_segments but be an int greater than 2")
+            raise ValueError("number_of_blanket_segments but be an int greater than 2")
 
     def _make_blankets_layers(self):
         super()._make_blankets_layers()
         azimuth_placement_angles = np.linspace(
-            0, 360, self.number_of_blanket_segments, endpoint=False)
+            0, 360, self.number_of_blanket_segments, endpoint=False
+        )
         thin_cutter = paramak.BlanketCutterStar(
             distance=self.gap_between_blankets,
-            azimuth_placement_angle=azimuth_placement_angles)
+            azimuth_placement_angle=azimuth_placement_angles,
+        )
 
         thick_cutter = paramak.BlanketCutterStar(
-            distance=self.gap_between_blankets +
-            2 * self.firstwall_radial_thickness,
-            azimuth_placement_angle=azimuth_placement_angles)
+            distance=self.gap_between_blankets + 2 * self.firstwall_radial_thickness,
+            azimuth_placement_angle=azimuth_placement_angles,
+        )
 
         self._blanket.cut = [self._center_column_cutter, thick_cutter]
 
@@ -89,18 +90,15 @@ def _make_blankets_layers(self):
             # tried firstwall start radius here already
             x = self.major_radius + 1
             front_face_b = self._blanket.solid.faces(
-                cq.NearestToPointSelector((0, x, 0)))
-            front_edge_b = front_face_b.edges(
-                cq.NearestToPointSelector((0, x, 0)))
+                cq.NearestToPointSelector((0, x, 0))
+            )
+            front_edge_b = front_face_b.edges(cq.NearestToPointSelector((0, x, 0)))
             front_edge_length_b = front_edge_b.val().Length()
             self._blanket.solid = self._blanket.solid.edges(
-                paramak.EdgeLengthSelector(front_edge_length_b)).fillet(
-                self.blanket_fillet_radius)
+                paramak.EdgeLengthSelector(front_edge_length_b)
+            ).fillet(self.blanket_fillet_radius)
         self._firstwall.thickness += self.blanket_radial_thickness
-        self._firstwall.cut = [
-            self._center_column_cutter,
-            thin_cutter,
-            self._blanket]
+        self._firstwall.cut = [self._center_column_cutter, thin_cutter, self._blanket]
 
         # TODO this segfaults at the moment but works as an opperation on the
         # reactor after construction in jupyter
diff --git a/paramak/parametric_reactors/single_null_ball_reactor.py b/paramak/parametric_reactors/single_null_ball_reactor.py
index 50ea1af91..025ef1ca1 100644
--- a/paramak/parametric_reactors/single_null_ball_reactor.py
+++ b/paramak/parametric_reactors/single_null_ball_reactor.py
@@ -1,4 +1,3 @@
-
 import paramak
 
 
@@ -12,10 +11,6 @@ class SingleNullBallReactor(paramak.BallReactor):
         divertor_position (str): Defaults to "upper".
     """
 
-    def __init__(
-        self,
-        divertor_position: str = "upper",
-        **kwargs
-    ):
+    def __init__(self, divertor_position: str = "upper", **kwargs):
 
         super().__init__(divertor_position=divertor_position, **kwargs)
diff --git a/paramak/parametric_reactors/single_null_submersion_reactor.py b/paramak/parametric_reactors/single_null_submersion_reactor.py
index 94dff8a58..70b03a24d 100644
--- a/paramak/parametric_reactors/single_null_submersion_reactor.py
+++ b/paramak/parametric_reactors/single_null_submersion_reactor.py
@@ -1,4 +1,3 @@
-
 import paramak
 
 
@@ -23,4 +22,5 @@ def __init__(
         super().__init__(
             divertor_position=divertor_position,
             support_position=support_position,
-            **kwargs)
+            **kwargs
+        )
diff --git a/paramak/parametric_reactors/sparc_paper_2020.py b/paramak/parametric_reactors/sparc_paper_2020.py
index 7e431238d..50e816dd1 100644
--- a/paramak/parametric_reactors/sparc_paper_2020.py
+++ b/paramak/parametric_reactors/sparc_paper_2020.py
@@ -1,3 +1,4 @@
+from typing import List
 
 import paramak
 
@@ -24,8 +25,8 @@ def __init__(
         self.rotation_angle = rotation_angle
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'rotation_angle',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "rotation_angle",
         ]
 
     def create_pf_coils(self):
@@ -45,7 +46,14 @@ def create_pf_coils(self):
                 (53.5, 118.43),
                 (53.5, 169.58),
             ],
-            heights=[41.5, 40.5, 82.95, 82.95, 40.5, 41.5, ],
+            heights=[
+                41.5,
+                40.5,
+                82.95,
+                82.95,
+                40.5,
+                41.5,
+            ],
             widths=[27.7, 27.7, 27.7, 27.7, 27.7, 27.7],
             rotation_angle=self.rotation_angle,
         )
@@ -61,8 +69,26 @@ def create_pf_coils(self):
                 (373, 131),
                 (373, -131),
             ],
-            widths=[32, 32, 50, 50, 43, 43, 48, 48, ],
-            heights=[40, 40, 30, 30, 28, 28, 37, 37, ],
+            widths=[
+                32,
+                32,
+                50,
+                50,
+                43,
+                43,
+                48,
+                48,
+            ],
+            heights=[
+                40,
+                40,
+                30,
+                30,
+                28,
+                28,
+                37,
+                37,
+            ],
             rotation_angle=self.rotation_angle,
         )
 
@@ -72,7 +98,6 @@ def create_pf_coils(self):
                 (207, 125),
                 (207, -144),
                 (207, -125),
-
             ],
             widths=[15, 15, 15, 15],
             heights=[15, 15, 15, 15],
@@ -151,16 +176,23 @@ def create_pf_coils(self):
         )
 
         return [
-            inboard_pf_coils, outboard_pf_coils, div_coils,
-            efccu_coils_1, efccu_coils_2, efccu_coils_3,
-            efccu_coils_4, efccu_coils_5, efccu_coils_6, vs_coils
+            inboard_pf_coils,
+            outboard_pf_coils,
+            div_coils,
+            efccu_coils_1,
+            efccu_coils_2,
+            efccu_coils_3,
+            efccu_coils_4,
+            efccu_coils_5,
+            efccu_coils_6,
+            vs_coils,
         ]
 
     def create_tf_coils(self):
         """Creates a 3d solids for each tf coil.
 
-           Returns:
-              A list of CadQuery solids: A list of 3D solid volumes
+        Returns:
+           A list of CadQuery solids: A list of 3D solid volumes
 
         """
 
@@ -190,11 +222,11 @@ def create_vessel_components(self, vs_coils):
 
         antenna = paramak.RotateMixedShape(
             points=[
-                (263.2794457274827, 46.5437788018433, 'straight'),
-                (263.2794457274827, -46.54377880184336, 'straight'),
-                (231.87066974595842, -46.54377880184336, 'spline'),
-                (243.87990762124713, 0, 'spline'),
-                (231.87066974595842, 46.5437788018433, 'straight'),
+                (263.2794457274827, 46.5437788018433, "straight"),
+                (263.2794457274827, -46.54377880184336, "straight"),
+                (231.87066974595842, -46.54377880184336, "spline"),
+                (243.87990762124713, 0, "spline"),
+                (231.87066974595842, 46.5437788018433, "straight"),
             ],
             rotation_angle=self.rotation_angle,
         )
@@ -236,58 +268,58 @@ def create_vessel_components(self, vs_coils):
                 (117.32101616628177, 123.04147465437785),
             ],
             rotation_angle=self.rotation_angle,
-            color=(0., 1., 1.),
+            color=(0.0, 1.0, 1.0),
         )
 
         inner_vessel = paramak.RotateMixedShape(
             points=[
-                (269.7459584295612, -46.54377880184336, 'straight'),
-                (231.87066974595842, -46.5437788018433, 'spline'),
-                (223.55658198614316, -62.21198156682027, 'spline'),
-                (207.85219399538107, -80.64516129032262, 'spline'),
-                (166.28175519630486, -115.66820276497697, 'spline'),
-                (164.43418013856814, -119.35483870967744, 'spline'),
-                (164.43418013856814, -122.11981566820276, 'straight'),
-                (173.67205542725173, -140.5529953917051, 'straight'),
-                (184.75750577367205, -140.5529953917051, 'straight'),
-                (184.75750577367205, -158.98617511520735, 'straight'),
-                (181.98614318706697, -159.9078341013825, 'straight'),
-                (147.80600461893764, -118.43317972350235, 'straight'),
-                (129.33025404157044, -123.04147465437785, 'straight'),
-                (145.95842956120094, -111.05990783410135, 'straight'),
-                (126.55889145496536, -50.23041474654377, 'straight'),
-                (127.48267898383372, 50.23041474654377, 'straight'),
-                (145.95842956120094, 110.13824884792626, 'straight'),
-                (128.40646651270208, 123.04147465437785, 'straight'),
-                (147.80600461893764, 117.51152073732717, 'straight'),
-                (181.98614318706697, 159.90783410138246, 'straight'),
-                (185.6812933025404, 158.98617511520735, 'straight'),
-                (184.75750577367205, 140.55299539170505, 'straight'),
-                (172.74826789838338, 140.55299539170505, 'spline'),
-                (164.43418013856814, 121.19815668202764, 'spline'),
-                (164.43418013856814, 118.43317972350229, 'spline'),
-                (165.3579676674365, 115.66820276497694, 'spline'),
-                (173.67205542725173, 111.05990783410135, 'spline'),
-                (207.85219399538107, 80.64516129032256, 'spline'),
-                (220.7852193995381, 66.82027649769586, 'spline'),
-                (231.87066974595842, 46.5437788018433, 'spline'),
-                (268.82217090069287, 46.5437788018433, 'straight'),
-                (268.82217090069287, 63.13364055299536, 'straight'),
-                (233.71824480369514, 111.98156682027647, 'straight'),
-                (193.99538106235568, 112.90322580645159, 'straight'),
-                (192.14780600461893, 164.51612903225805, 'straight'),
-                (163.51039260969978, 166.35944700460828, 'straight'),
-                (121.93995381062356, 123.96313364055297, 'straight'),
-                (121.0161662817552, -125.80645161290323, 'straight'),
-                (163.51039260969978, -166.35944700460834, 'straight'),
-                (192.14780600461893, -166.35944700460834, 'straight'),
-                (193.99538106235568, -112.90322580645159, 'straight'),
-                (234.64203233256353, -111.9815668202765, 'straight'),
-                (269.7459584295612, -63.13364055299536, 'straight'),
+                (269.7459584295612, -46.54377880184336, "straight"),
+                (231.87066974595842, -46.5437788018433, "spline"),
+                (223.55658198614316, -62.21198156682027, "spline"),
+                (207.85219399538107, -80.64516129032262, "spline"),
+                (166.28175519630486, -115.66820276497697, "spline"),
+                (164.43418013856814, -119.35483870967744, "spline"),
+                (164.43418013856814, -122.11981566820276, "straight"),
+                (173.67205542725173, -140.5529953917051, "straight"),
+                (184.75750577367205, -140.5529953917051, "straight"),
+                (184.75750577367205, -158.98617511520735, "straight"),
+                (181.98614318706697, -159.9078341013825, "straight"),
+                (147.80600461893764, -118.43317972350235, "straight"),
+                (129.33025404157044, -123.04147465437785, "straight"),
+                (145.95842956120094, -111.05990783410135, "straight"),
+                (126.55889145496536, -50.23041474654377, "straight"),
+                (127.48267898383372, 50.23041474654377, "straight"),
+                (145.95842956120094, 110.13824884792626, "straight"),
+                (128.40646651270208, 123.04147465437785, "straight"),
+                (147.80600461893764, 117.51152073732717, "straight"),
+                (181.98614318706697, 159.90783410138246, "straight"),
+                (185.6812933025404, 158.98617511520735, "straight"),
+                (184.75750577367205, 140.55299539170505, "straight"),
+                (172.74826789838338, 140.55299539170505, "spline"),
+                (164.43418013856814, 121.19815668202764, "spline"),
+                (164.43418013856814, 118.43317972350229, "spline"),
+                (165.3579676674365, 115.66820276497694, "spline"),
+                (173.67205542725173, 111.05990783410135, "spline"),
+                (207.85219399538107, 80.64516129032256, "spline"),
+                (220.7852193995381, 66.82027649769586, "spline"),
+                (231.87066974595842, 46.5437788018433, "spline"),
+                (268.82217090069287, 46.5437788018433, "straight"),
+                (268.82217090069287, 63.13364055299536, "straight"),
+                (233.71824480369514, 111.98156682027647, "straight"),
+                (193.99538106235568, 112.90322580645159, "straight"),
+                (192.14780600461893, 164.51612903225805, "straight"),
+                (163.51039260969978, 166.35944700460828, "straight"),
+                (121.93995381062356, 123.96313364055297, "straight"),
+                (121.0161662817552, -125.80645161290323, "straight"),
+                (163.51039260969978, -166.35944700460834, "straight"),
+                (192.14780600461893, -166.35944700460834, "straight"),
+                (193.99538106235568, -112.90322580645159, "straight"),
+                (234.64203233256353, -111.9815668202765, "straight"),
+                (269.7459584295612, -63.13364055299536, "straight"),
             ],
             rotation_angle=self.rotation_angle,
             cut=[vac_vessel, vs_coils, antenna],
-            color=(0., 1., 0.498),
+            color=(0.0, 1.0, 0.498),
         )
 
         return [antenna, vac_vessel, inner_vessel]
diff --git a/paramak/parametric_reactors/submersion_reactor.py b/paramak/parametric_reactors/submersion_reactor.py
index 9ce156c53..d28264160 100644
--- a/paramak/parametric_reactors/submersion_reactor.py
+++ b/paramak/parametric_reactors/submersion_reactor.py
@@ -1,8 +1,8 @@
-
 import warnings
 from typing import List, Optional, Union
 
 import cadquery as cq
+
 import paramak
 
 
@@ -56,7 +56,7 @@ class SubmersionTokamak(paramak.Reactor):
 
     def __init__(
         self,
-        inner_bore_radial_thickness: float = 30.,
+        inner_bore_radial_thickness: float = 30.0,
         inboard_tf_leg_radial_thickness: float = 30,
         center_column_shield_radial_thickness: float = 30,
         inboard_blanket_radial_thickness: float = 80,
@@ -68,10 +68,10 @@ def __init__(
         outer_plasma_gap_radial_thickness: float = 50,
         outboard_blanket_radial_thickness: float = 30,
         blanket_rear_wall_radial_thickness: float = 30,
-        elongation: float = 2.,
+        elongation: float = 2.0,
         triangularity: float = 0.5,
         number_of_tf_coils: int = 16,
-        rotation_angle: float = 360.,
+        rotation_angle: float = 360.0,
         outboard_tf_coil_radial_thickness: Optional[float] = None,
         rear_blanket_to_tf_gap: Optional[float] = None,
         outboard_tf_coil_poloidal_thickness: Optional[float] = None,
@@ -91,29 +91,21 @@ def __init__(
         self.center_column_shield_radial_thickness = (
             center_column_shield_radial_thickness
         )
-        self.inboard_blanket_radial_thickness = \
-            inboard_blanket_radial_thickness
+        self.inboard_blanket_radial_thickness = inboard_blanket_radial_thickness
         self.firstwall_radial_thickness = firstwall_radial_thickness
-        self.inner_plasma_gap_radial_thickness = \
-            inner_plasma_gap_radial_thickness
+        self.inner_plasma_gap_radial_thickness = inner_plasma_gap_radial_thickness
         self.plasma_radial_thickness = plasma_radial_thickness
-        self.outer_plasma_gap_radial_thickness = \
-            outer_plasma_gap_radial_thickness
-        self.outboard_blanket_radial_thickness = \
-            outboard_blanket_radial_thickness
-        self.blanket_rear_wall_radial_thickness = \
-            blanket_rear_wall_radial_thickness
+        self.outer_plasma_gap_radial_thickness = outer_plasma_gap_radial_thickness
+        self.outboard_blanket_radial_thickness = outboard_blanket_radial_thickness
+        self.blanket_rear_wall_radial_thickness = blanket_rear_wall_radial_thickness
         self.pf_coil_radial_thicknesses = pf_coil_radial_thicknesses
-        self.outboard_tf_coil_radial_thickness = \
-            outboard_tf_coil_radial_thickness
-        self.outboard_tf_coil_poloidal_thickness = \
-            outboard_tf_coil_poloidal_thickness
+        self.outboard_tf_coil_radial_thickness = outboard_tf_coil_radial_thickness
+        self.outboard_tf_coil_poloidal_thickness = outboard_tf_coil_poloidal_thickness
         self.divertor_radial_thickness = divertor_radial_thickness
         self.support_radial_thickness = support_radial_thickness
         self.elongation = elongation
         self.triangularity = triangularity
-        self.rear_blanket_to_tf_gap = \
-            rear_blanket_to_tf_gap
+        self.rear_blanket_to_tf_gap = rear_blanket_to_tf_gap
         self.pf_coil_vertical_thicknesses = pf_coil_vertical_thicknesses
         self.pf_coil_case_thicknesses = pf_coil_case_thicknesses
         self.number_of_tf_coils = number_of_tf_coils
@@ -124,33 +116,33 @@ def __init__(
         self.pf_coil_radial_position = pf_coil_radial_position
 
         # adds self.input_variable_names from the Reactor class
-        self.input_variable_names = self.input_variable_names + [
-            'inner_bore_radial_thickness',
-            'inboard_tf_leg_radial_thickness',
-            'center_column_shield_radial_thickness',
-            'inboard_blanket_radial_thickness',
-            'firstwall_radial_thickness',
-            'inner_plasma_gap_radial_thickness',
-            'plasma_radial_thickness',
-            'divertor_radial_thickness',
-            'support_radial_thickness',
-            'outer_plasma_gap_radial_thickness',
-            'outboard_blanket_radial_thickness',
-            'blanket_rear_wall_radial_thickness',
-            'elongation',
-            'triangularity',
-            'number_of_tf_coils',
-            'rotation_angle',
-            'outboard_tf_coil_radial_thickness',
-            'rear_blanket_to_tf_gap',
-            'outboard_tf_coil_poloidal_thickness',
-            'pf_coil_vertical_thicknesses',
-            'pf_coil_radial_thicknesses',
-            'pf_coil_radial_position',
-            'pf_coil_vertical_position',
-            'pf_coil_case_thicknesses',
-            'divertor_position',
-            'support_position',
+        self.input_variable_names: List[str] = self.input_variable_names + [
+            "inner_bore_radial_thickness",
+            "inboard_tf_leg_radial_thickness",
+            "center_column_shield_radial_thickness",
+            "inboard_blanket_radial_thickness",
+            "firstwall_radial_thickness",
+            "inner_plasma_gap_radial_thickness",
+            "plasma_radial_thickness",
+            "divertor_radial_thickness",
+            "support_radial_thickness",
+            "outer_plasma_gap_radial_thickness",
+            "outboard_blanket_radial_thickness",
+            "blanket_rear_wall_radial_thickness",
+            "elongation",
+            "triangularity",
+            "number_of_tf_coils",
+            "rotation_angle",
+            "outboard_tf_coil_radial_thickness",
+            "rear_blanket_to_tf_gap",
+            "outboard_tf_coil_poloidal_thickness",
+            "pf_coil_vertical_thicknesses",
+            "pf_coil_radial_thicknesses",
+            "pf_coil_radial_position",
+            "pf_coil_vertical_position",
+            "pf_coil_case_thicknesses",
+            "divertor_position",
+            "support_position",
         ]
 
         # set by make_plasma
@@ -246,8 +238,10 @@ def create_solids(self):
     def _rotation_angle_check(self):
 
         if self.rotation_angle == 360:
-            msg = "360 degree rotation may result" + \
-                " in a Standard_ConstructionError or AttributeError"
+            msg = (
+                "360 degree rotation may result"
+                + " in a Standard_ConstructionError or AttributeError"
+            )
             warnings.warn(msg, UserWarning)
 
     def _make_radial_build(self):
@@ -262,60 +256,55 @@ def _make_radial_build(self):
 
         self._inboard_tf_coils_start_radius = self._inner_bore_end_radius
         self._inboard_tf_coils_end_radius = (
-            self._inboard_tf_coils_start_radius +
-            self.inboard_tf_leg_radial_thickness)
+            self._inboard_tf_coils_start_radius + self.inboard_tf_leg_radial_thickness
+        )
 
-        self._center_column_shield_start_radius = \
-            self._inboard_tf_coils_end_radius
+        self._center_column_shield_start_radius = self._inboard_tf_coils_end_radius
         self._center_column_shield_end_radius = (
             self._center_column_shield_start_radius
             + self.center_column_shield_radial_thickness
         )
 
-        self._inboard_blanket_start_radius = \
-            self._center_column_shield_end_radius
+        self._inboard_blanket_start_radius = self._center_column_shield_end_radius
         self._inboard_blanket_end_radius = (
-            self._inboard_blanket_start_radius +
-            self.inboard_blanket_radial_thickness)
+            self._inboard_blanket_start_radius + self.inboard_blanket_radial_thickness
+        )
 
         self._inboard_firstwall_start_radius = self._inboard_blanket_end_radius
         self._inboard_firstwall_end_radius = (
-            self._inboard_firstwall_start_radius +
-            self.firstwall_radial_thickness)
+            self._inboard_firstwall_start_radius + self.firstwall_radial_thickness
+        )
 
-        self._inner_plasma_gap_start_radius = \
-            self._inboard_firstwall_end_radius
+        self._inner_plasma_gap_start_radius = self._inboard_firstwall_end_radius
         self._inner_plasma_gap_end_radius = (
-            self._inner_plasma_gap_start_radius +
-            self.inner_plasma_gap_radial_thickness)
+            self._inner_plasma_gap_start_radius + self.inner_plasma_gap_radial_thickness
+        )
 
         self._plasma_start_radius = self._inner_plasma_gap_end_radius
-        self._plasma_end_radius = \
-            self._plasma_start_radius + \
-            self.plasma_radial_thickness
+        self._plasma_end_radius = (
+            self._plasma_start_radius + self.plasma_radial_thickness
+        )
 
         self._outer_plasma_gap_start_radius = self._plasma_end_radius
         self._outer_plasma_gap_end_radius = (
-            self._outer_plasma_gap_start_radius +
-            self.outer_plasma_gap_radial_thickness)
+            self._outer_plasma_gap_start_radius + self.outer_plasma_gap_radial_thickness
+        )
 
-        self._outboard_firstwall_start_radius = \
-            self._outer_plasma_gap_end_radius
+        self._outboard_firstwall_start_radius = self._outer_plasma_gap_end_radius
         self._outboard_firstwall_end_radius = (
-            self._outboard_firstwall_start_radius +
-            self.firstwall_radial_thickness)
+            self._outboard_firstwall_start_radius + self.firstwall_radial_thickness
+        )
 
-        self._outboard_blanket_start_radius = \
-            self._outboard_firstwall_end_radius
+        self._outboard_blanket_start_radius = self._outboard_firstwall_end_radius
         self._outboard_blanket_end_radius = (
-            self._outboard_blanket_start_radius +
-            self.outboard_blanket_radial_thickness)
+            self._outboard_blanket_start_radius + self.outboard_blanket_radial_thickness
+        )
 
-        self._blanket_rear_wall_start_radius = \
-            self._outboard_blanket_end_radius
+        self._blanket_rear_wall_start_radius = self._outboard_blanket_end_radius
         self._blanket_rear_wall_end_radius = (
-            self._blanket_rear_wall_start_radius +
-            self.blanket_rear_wall_radial_thickness)
+            self._blanket_rear_wall_start_radius
+            + self.blanket_rear_wall_radial_thickness
+        )
 
         self._tf_info_provided = False
         if (
@@ -325,11 +314,12 @@ def _make_radial_build(self):
         ):
             self._tf_info_provided = True
             self._outboard_tf_coil_start_radius = (
-                self._blanket_rear_wall_end_radius +
-                self.rear_blanket_to_tf_gap)
+                self._blanket_rear_wall_end_radius + self.rear_blanket_to_tf_gap
+            )
             self._outboard_tf_coil_end_radius = (
-                self._outboard_tf_coil_start_radius +
-                self.outboard_tf_coil_radial_thickness)
+                self._outboard_tf_coil_start_radius
+                + self.outboard_tf_coil_radial_thickness
+            )
 
         self._divertor_start_radius = (
             self._plasma.high_point[0] - 0.5 * self.divertor_radial_thickness
@@ -355,13 +345,15 @@ def _make_vertical_build(self):
 
         self._plasma_to_divertor_gap_start_height = self._plasma_end_height
         self._plasma_to_divertor_gap_end_height = (
-            self._plasma_to_divertor_gap_start_height +
-            self.outer_plasma_gap_radial_thickness)
+            self._plasma_to_divertor_gap_start_height
+            + self.outer_plasma_gap_radial_thickness
+        )
 
         # the firstwall is cut by the divertor but uses the same control points
         self._firstwall_start_height = self._plasma_to_divertor_gap_end_height
-        self._firstwall_end_height = self._firstwall_start_height + \
-            self.firstwall_radial_thickness
+        self._firstwall_end_height = (
+            self._firstwall_start_height + self.firstwall_radial_thickness
+        )
 
         self._blanket_start_height = self._firstwall_end_height
         self._blanket_end_height = (
@@ -370,14 +362,17 @@ def _make_vertical_build(self):
 
         self._blanket_rear_wall_start_height = self._blanket_end_height
         self._blanket_rear_wall_end_height = (
-            self._blanket_rear_wall_start_height +
-            self.blanket_rear_wall_radial_thickness)
+            self._blanket_rear_wall_start_height
+            + self.blanket_rear_wall_radial_thickness
+        )
 
         if self._tf_info_provided:
-            self._outboard_tf_coils_vertical_height = \
+            self._outboard_tf_coils_vertical_height = (
                 self._blanket_rear_wall_end_height * 1.5
-            self._outboard_tf_coils_horizontal_length = \
+            )
+            self._outboard_tf_coils_horizontal_length = (
                 self._blanket_rear_wall_end_radius * 0.75
+            )
 
     def _make_center_column_shield(self):
 
@@ -403,10 +398,8 @@ def _make_plasma(self):
             + self.firstwall_radial_thickness
             + self.inner_plasma_gap_radial_thickness
         )
-        outer_equatorial_point = \
-            inner_equatorial_point + self.plasma_radial_thickness
-        self.major_radius = \
-            (outer_equatorial_point + inner_equatorial_point) / 2
+        outer_equatorial_point = inner_equatorial_point + self.plasma_radial_thickness
+        self.major_radius = (outer_equatorial_point + inner_equatorial_point) / 2
         self.minor_radius = self.major_radius - inner_equatorial_point
 
         plasma = paramak.Plasma(
@@ -482,12 +475,12 @@ def _make_divertor(self):
                 (self._divertor_start_radius, divertor_height_bottom),
                 (self._divertor_end_radius, divertor_height_bottom),
                 (self._divertor_end_radius, divertor_height_top),
-                (self._divertor_start_radius, divertor_height_top)
+                (self._divertor_start_radius, divertor_height_top),
             ],
             intersect=fw_envelope,
             rotation_angle=self.rotation_angle,
             name="divertor",
-            color=(1., 0.667, 0.),
+            color=(1.0, 0.667, 0.0),
         )
 
         self._firstwall.cut = self._divertor
@@ -521,7 +514,7 @@ def _make_blanket(self):
             thickness=self.outboard_blanket_radial_thickness,
             rotation_angle=self.rotation_angle,
             name="blanket",
-            color=(0., 1., 0.498),
+            color=(0.0, 1.0, 0.498),
             union=self._inboard_blanket,
         )
         return self._blanket
@@ -551,11 +544,11 @@ def _make_supports(self):
                 (self._support_start_radius, support_height_bottom),
                 (self._support_end_radius, support_height_bottom),
                 (self._support_end_radius, support_height_top),
-                (self._support_start_radius, support_height_top)
+                (self._support_start_radius, support_height_top),
             ],
             rotation_angle=self.rotation_angle,
             name="supports",
-            color=(0., 0., 0.),
+            color=(0.0, 0.0, 0.0),
             intersect=blanket_envelope,
         )
 
@@ -568,11 +561,11 @@ def _make_rear_blanket_wall(self):
             points=[
                 (
                     self._center_column_shield_end_radius,
-                    self._blanket_rear_wall_start_height
+                    self._blanket_rear_wall_start_height,
                 ),
                 (
                     self._center_column_shield_end_radius,
-                    self._blanket_rear_wall_end_height
+                    self._blanket_rear_wall_end_height,
                 ),
                 (
                     max(self._inboard_firstwall.points)[0],
@@ -590,11 +583,11 @@ def _make_rear_blanket_wall(self):
             points=[
                 (
                     self._center_column_shield_end_radius,
-                    -self._blanket_rear_wall_start_height
+                    -self._blanket_rear_wall_start_height,
                 ),
                 (
                     self._center_column_shield_end_radius,
-                    -self._blanket_rear_wall_end_height
+                    -self._blanket_rear_wall_end_height,
                 ),
                 (
                     max(self._inboard_firstwall.points)[0],
@@ -612,32 +605,38 @@ def _make_rear_blanket_wall(self):
             plasma=self._plasma,
             start_angle=90,
             stop_angle=-90,
-            offset_from_plasma=self.outer_plasma_gap_radial_thickness +
-            self.firstwall_radial_thickness +
-            self.outboard_blanket_radial_thickness,
+            offset_from_plasma=self.outer_plasma_gap_radial_thickness
+            + self.firstwall_radial_thickness
+            + self.outboard_blanket_radial_thickness,
             thickness=self.blanket_rear_wall_radial_thickness,
             rotation_angle=self.rotation_angle,
             name="outboard_rear_blanket_wall",
-            color=(0., 1., 1.),
+            color=(0.0, 1.0, 1.0),
             union=[
                 self._outboard_rear_blanket_wall_upper,
-                self._outboard_rear_blanket_wall_lower],
+                self._outboard_rear_blanket_wall_lower,
+            ],
         )
 
         return self._outboard_rear_blanket_wall
 
     def _make_pf_coils(self):
-        if None not in [self.pf_coil_vertical_thicknesses,
-                        self.pf_coil_radial_thicknesses,
-                        self.pf_coil_vertical_position,
-                        self.pf_coil_radial_position]:
+        if None not in [
+            self.pf_coil_vertical_thicknesses,
+            self.pf_coil_radial_thicknesses,
+            self.pf_coil_vertical_position,
+            self.pf_coil_radial_position,
+        ]:
             list_of_components = []
 
             # TODO make use of counter in the name attribute
 
             center_points = [
-                (x, y) for x, y in zip(
-                    self.pf_coil_radial_position, self.pf_coil_vertical_position)]
+                (x, y)
+                for x, y in zip(
+                    self.pf_coil_radial_position, self.pf_coil_vertical_position
+                )
+            ]
 
             self._pf_coils = self._pf_coil = paramak.PoloidalFieldCoilSet(
                 heights=self.pf_coil_vertical_thicknesses,
@@ -660,9 +659,10 @@ def _make_pf_coils(self):
             return list_of_components
         else:
             print(
-                'pf_coil_vertical_thicknesses, pf_coil_radial_thicknesses, '
-                'pf_coil_radial_position, pf_coil_vertical_position not '
-                'so not making pf coils')
+                "pf_coil_vertical_thicknesses, pf_coil_radial_thicknesses, "
+                "pf_coil_radial_position, pf_coil_vertical_position not "
+                "so not making pf coils"
+            )
             return None
 
     def _make_tf_coils(self):
@@ -678,11 +678,16 @@ def _make_tf_coils(self):
         )
         list_of_components.append(self._inboard_tf_coils)
 
-        if None not in [
+        if (
+            None
+            not in [
                 self.rear_blanket_to_tf_gap,
                 self.outboard_tf_coil_radial_thickness,
                 self.outboard_tf_coil_poloidal_thickness,
-                self.number_of_tf_coils] and self.number_of_tf_coils > 1:
+                self.number_of_tf_coils,
+            ]
+            and self.number_of_tf_coils > 1
+        ):
 
             if self._tf_info_provided:
                 self._tf_coil = paramak.ToroidalFieldCoilCoatHanger(
@@ -697,7 +702,7 @@ def _make_tf_coils(self):
                     distance=self.outboard_tf_coil_poloidal_thickness,
                     rotation_angle=self.rotation_angle,
                     horizontal_length=self._outboard_tf_coils_horizontal_length,
-                    vertical_length=self._outboard_tf_coils_vertical_height
+                    vertical_length=self._outboard_tf_coils_vertical_height,
                 )
                 list_of_components.append(self._tf_coil)
 
diff --git a/paramak/parametric_shapes/extruded_circle_shape.py b/paramak/parametric_shapes/extruded_circle_shape.py
index f65ad6b9d..d6b6a56c5 100644
--- a/paramak/parametric_shapes/extruded_circle_shape.py
+++ b/paramak/parametric_shapes/extruded_circle_shape.py
@@ -1,7 +1,7 @@
-
 from typing import Optional, Tuple
 
 from cadquery import Workplane
+
 from paramak import Shape
 from paramak.utils import calculate_wedge_cut
 
@@ -26,16 +26,16 @@ def __init__(
         extrusion_start_offset: Optional[float] = 0.0,
         rotation_angle: Optional[float] = 360,
         extrude_both: Optional[bool] = True,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.984, 0.603, 0.6),
-        name: str = 'extrudecircleshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.984,
+            0.603,
+            0.6,
+        ),
+        name: str = "extrudecircleshape",
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(color=color, name=name, **kwargs)
 
         self.distance = distance
         self.radius = radius
@@ -80,8 +80,8 @@ def extrusion_start_offset(self, value):
     def create_solid(self):
         """Creates a extruded 3d solid using points with circular edges.
 
-           Returns:
-              A CadQuery solid: A 3D solid volume
+        Returns:
+           A CadQuery solid: A 3D solid volume
         """
 
         # so a positive offset moves extrusion further from axis of azimuthal
@@ -102,9 +102,7 @@ def create_solid(self):
 
         self.wire = wire
 
-        solid = wire.extrude(
-            distance=extrusion_distance,
-            both=self.extrude_both)
+        solid = wire.extrude(distance=extrusion_distance, both=self.extrude_both)
 
         solid = self.rotate_solid(solid)
         cutting_wedge = calculate_wedge_cut(self)
diff --git a/paramak/parametric_shapes/extruded_mixed_shape.py b/paramak/parametric_shapes/extruded_mixed_shape.py
index 15b50acbe..78bad1439 100644
--- a/paramak/parametric_shapes/extruded_mixed_shape.py
+++ b/paramak/parametric_shapes/extruded_mixed_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import Shape
@@ -24,16 +23,16 @@ def __init__(
         extrude_both: Optional[bool] = True,
         rotation_angle: Optional[float] = 360.0,
         extrusion_start_offset: Optional[float] = 0.0,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.2, 0.627, 0.172),
-        name: str = 'extrudemixedshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.2,
+            0.627,
+            0.172,
+        ),
+        name: str = "extrudemixedshape",
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(color=color, name=name, **kwargs)
         self.distance = distance
         self.extrude_both = extrude_both
         self.rotation_angle = rotation_angle
@@ -84,9 +83,7 @@ def create_solid(self):
 
         self.wire = wire
 
-        solid = wire.extrude(
-            distance=extrusion_distance,
-            both=self.extrude_both)
+        solid = wire.extrude(distance=extrusion_distance, both=self.extrude_both)
 
         # filleting rectangular port cutter edges
         # must be done before azimuthal placement
diff --git a/paramak/parametric_shapes/extruded_spline_shape.py b/paramak/parametric_shapes/extruded_spline_shape.py
index 01ef5e2b3..56ec36e92 100644
--- a/paramak/parametric_shapes/extruded_spline_shape.py
+++ b/paramak/parametric_shapes/extruded_spline_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import ExtrudeMixedShape
@@ -16,8 +15,12 @@ class ExtrudeSplineShape(ExtrudeMixedShape):
     def __init__(
         self,
         distance: float,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.984, 0.603, 0.6),
-        name: str = 'extrudesplineshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.984,
+            0.603,
+            0.6,
+        ),
+        name: str = "extrudesplineshape",
         **kwargs
     ):
 
diff --git a/paramak/parametric_shapes/extruded_straight_shape.py b/paramak/parametric_shapes/extruded_straight_shape.py
index 65a75ad8e..0f409b05b 100644
--- a/paramak/parametric_shapes/extruded_straight_shape.py
+++ b/paramak/parametric_shapes/extruded_straight_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import ExtrudeMixedShape
@@ -15,8 +14,12 @@ class ExtrudeStraightShape(ExtrudeMixedShape):
     def __init__(
         self,
         distance: float,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (1.0, 0.498, 0.0),
-        name: str = 'extrudestraightshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            1.0,
+            0.498,
+            0.0,
+        ),
+        name: str = "extrudestraightshape",
         **kwargs
     ):
 
diff --git a/paramak/parametric_shapes/rotate_circle_shape.py b/paramak/parametric_shapes/rotate_circle_shape.py
index c49432ed3..ad3c93cb4 100644
--- a/paramak/parametric_shapes/rotate_circle_shape.py
+++ b/paramak/parametric_shapes/rotate_circle_shape.py
@@ -1,7 +1,7 @@
-
 from typing import Optional, Tuple
 
 from cadquery import Workplane
+
 from paramak import Shape
 
 
@@ -18,16 +18,12 @@ def __init__(
         self,
         radius: float,
         rotation_angle: Optional[float] = 360.0,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (1., 1., 0.6),
-        name: str = 'rotatecircleshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (1.0, 1.0, 0.6),
+        name: str = "rotatecircleshape",
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(color=color, name=name, **kwargs)
         self.radius = radius
         self.rotation_angle = rotation_angle
         self.color = color
@@ -52,8 +48,8 @@ def radius(self, value):
     def create_solid(self):
         """Creates a rotated 3d solid using points with circular edges.
 
-           Returns:
-              A CadQuery solid: A 3D solid volume
+        Returns:
+           A CadQuery solid: A 3D solid volume
         """
 
         wire = (
diff --git a/paramak/parametric_shapes/rotate_mixed_shape.py b/paramak/parametric_shapes/rotate_mixed_shape.py
index 785b73a84..291b91551 100644
--- a/paramak/parametric_shapes/rotate_mixed_shape.py
+++ b/paramak/parametric_shapes/rotate_mixed_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import Shape
@@ -15,17 +14,17 @@ class RotateMixedShape(Shape):
 
     def __init__(
         self,
-        rotation_angle: Optional[float] = 360.,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.121, 0.47, 0.705),
-        name: str = 'rotatemixedshape',
+        rotation_angle: Optional[float] = 360.0,
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.121,
+            0.47,
+            0.705,
+        ),
+        name: str = "rotatemixedshape",
         **kwargs
     ):
 
-        super().__init__(
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(color=color, name=name, **kwargs)
         self.rotation_angle = rotation_angle
         self.color = color
         self.name = name
diff --git a/paramak/parametric_shapes/rotate_spline_shape.py b/paramak/parametric_shapes/rotate_spline_shape.py
index 7240c6336..b96a7fa7b 100644
--- a/paramak/parametric_shapes/rotate_spline_shape.py
+++ b/paramak/parametric_shapes/rotate_spline_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import RotateMixedShape
@@ -14,9 +13,13 @@ class RotateSplineShape(RotateMixedShape):
 
     def __init__(
         self,
-        rotation_angle: Optional[float] = 360.,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.415, 0.239, 0.603),
-        name: str = 'rotatesplineshape',
+        rotation_angle: Optional[float] = 360.0,
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.415,
+            0.239,
+            0.603,
+        ),
+        name: str = "rotatesplineshape",
         **kwargs
     ):
 
diff --git a/paramak/parametric_shapes/rotate_straight_shape.py b/paramak/parametric_shapes/rotate_straight_shape.py
index 5ae9a3f4b..016a196e5 100644
--- a/paramak/parametric_shapes/rotate_straight_shape.py
+++ b/paramak/parametric_shapes/rotate_straight_shape.py
@@ -1,4 +1,3 @@
-
 from typing import Optional, Tuple
 
 from paramak import RotateMixedShape
@@ -15,9 +14,13 @@ class RotateStraightShape(RotateMixedShape):
 
     def __init__(
         self,
-        rotation_angle: Optional[float] = 360.,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.89, 0.101, 0.109),
-        name: str = 'rotatestraightshape',
+        rotation_angle: Optional[float] = 360.0,
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.89,
+            0.101,
+            0.109,
+        ),
+        name: str = "rotatestraightshape",
         **kwargs
     ):
 
diff --git a/paramak/parametric_shapes/sweep_circle_shape.py b/paramak/parametric_shapes/sweep_circle_shape.py
index 10aaf738d..d527f0cb9 100644
--- a/paramak/parametric_shapes/sweep_circle_shape.py
+++ b/paramak/parametric_shapes/sweep_circle_shape.py
@@ -1,7 +1,7 @@
-
-from typing import Optional, List, Tuple
+from typing import List, Optional, Tuple
 
 from cadquery import Workplane
+
 from paramak import Shape
 
 
@@ -30,17 +30,16 @@ def __init__(
         workplane: Optional[str] = "XY",
         path_workplane: Optional[str] = "XZ",
         force_cross_section: Optional[bool] = False,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.651, 0.808, 0.89),
-        name: str = 'sweepcircleshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.651,
+            0.808,
+            0.89,
+        ),
+        name: str = "sweepcircleshape",
         **kwargs
     ):
 
-        super().__init__(
-            workplane=workplane,
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(workplane=workplane, color=color, name=name, **kwargs)
 
         self.radius = radius
         self.path_points = path_points
@@ -78,9 +77,7 @@ def path_workplane(self, value):
                 "workplane and path_workplane must start with the same letter"
             )
         elif value == self.workplane:
-            raise ValueError(
-                "workplane and path_workplane must be different"
-            )
+            raise ValueError("workplane and path_workplane must be different")
         else:
             self._path_workplane = value
 
@@ -109,18 +106,16 @@ def create_solid(self):
 
                 wires.append(wire)
 
-                wire = (
-                    wire.center(-point[0], 0)
-                    .workplane(offset=-point[1] * factor)
-                )
+                wire = wire.center(-point[0], 0).workplane(offset=-point[1] * factor)
 
             self.wire = wires
 
-            solid = wire.workplane(
-                offset=self.path_points[-1][1] * factor) \
-                .center(self.path_points[-1][0], 0) \
-                .circle(self.radius) \
+            solid = (
+                wire.workplane(offset=self.path_points[-1][1] * factor)
+                .center(self.path_points[-1][0], 0)
+                .circle(self.radius)
                 .sweep(path, multisection=True)
+            )
 
         else:
 
diff --git a/paramak/parametric_shapes/sweep_mixed_shape.py b/paramak/parametric_shapes/sweep_mixed_shape.py
index 3a79f44ba..20c520bfc 100644
--- a/paramak/parametric_shapes/sweep_mixed_shape.py
+++ b/paramak/parametric_shapes/sweep_mixed_shape.py
@@ -1,7 +1,7 @@
-
-from typing import Optional, List, Tuple
+from typing import List, Optional, Tuple
 
 from cadquery import Workplane
+
 from paramak import Shape
 
 
@@ -29,17 +29,16 @@ def __init__(
         workplane: Optional[str] = "XY",
         path_workplane: Optional[str] = "XZ",
         force_cross_section: Optional[bool] = False,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.792, 0.698, 0.839),
-        name: str = 'sweepmixedshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.792,
+            0.698,
+            0.839,
+        ),
+        name: str = "sweepmixedshape",
         **kwargs
     ):
 
-        super().__init__(
-            workplane=workplane,
-            color=color,
-            name=name,
-            **kwargs
-        )
+        super().__init__(workplane=workplane, color=color, name=name, **kwargs)
 
         self.path_points = path_points
         self.workplane = workplane
@@ -67,9 +66,7 @@ def path_workplane(self, value):
                 "workplane and path_workplane must start with the same letter"
             )
         elif value == self.workplane:
-            raise ValueError(
-                "workplane and path_workplane must be different"
-            )
+            raise ValueError("workplane and path_workplane must be different")
         else:
             self._path_workplane = value
 
diff --git a/paramak/parametric_shapes/sweep_spline_shape.py b/paramak/parametric_shapes/sweep_spline_shape.py
index c0eb573dd..17a89e3f8 100644
--- a/paramak/parametric_shapes/sweep_spline_shape.py
+++ b/paramak/parametric_shapes/sweep_spline_shape.py
@@ -1,4 +1,3 @@
-
 from typing import List, Optional, Tuple
 
 from paramak import SweepMixedShape
@@ -28,8 +27,12 @@ def __init__(
         workplane: Optional[str] = "XY",
         path_workplane: Optional[str] = "XZ",
         force_cross_section: Optional[bool] = False,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.992, 0.749, 0.435),
-        name: str = 'sweepsplineshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.992,
+            0.749,
+            0.435,
+        ),
+        name: str = "sweepsplineshape",
         **kwargs
     ):
 
diff --git a/paramak/parametric_shapes/sweep_straight_shape.py b/paramak/parametric_shapes/sweep_straight_shape.py
index d930cb6be..0fb6bf605 100644
--- a/paramak/parametric_shapes/sweep_straight_shape.py
+++ b/paramak/parametric_shapes/sweep_straight_shape.py
@@ -1,5 +1,4 @@
-
-from typing import Optional, List, Tuple
+from typing import List, Optional, Tuple
 
 from paramak import SweepMixedShape
 
@@ -27,8 +26,12 @@ def __init__(
         workplane: Optional[str] = "XY",
         path_workplane: Optional[str] = "XZ",
         force_cross_section: Optional[bool] = False,
-        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.698, 0.8745, 0.541),
-        name: str = 'sweepstraightshape',
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (
+            0.698,
+            0.8745,
+            0.541,
+        ),
+        name: str = "sweepstraightshape",
         **kwargs
     ):
 
diff --git a/paramak/reactor.py b/paramak/reactor.py
index 0cd18cb0d..3f2a95195 100644
--- a/paramak/reactor.py
+++ b/paramak/reactor.py
@@ -47,17 +47,16 @@ def __init__(
         self.graveyard_size = graveyard_size
         self.largest_shapes = largest_shapes
 
-        self.input_variable_names = [
+        self.input_variable_names: List[str] = [
             # 'shapes_and_components', commented out to avoid calculating solids
             "graveyard_size",
             "graveyard_offset",
             "largest_shapes",
         ]
 
-        self.stp_filenames = []
-        self.stl_filenames = []
+        self.stp_filenames: List[str] = []
+        self.stl_filenames: List[str] = []
 
-        self.tet_meshes = []
         self.graveyard = None
         self.solid = None
 
@@ -110,9 +109,7 @@ def largest_dimension(self):
             shapes_to_bound = self.largest_shapes
 
         for component in shapes_to_bound:
-            largest_dimension = max(
-                largest_dimension,
-                component.largest_dimension)
+            largest_dimension = max(largest_dimension, component.largest_dimension)
         # self._largest_dimension = largest_dimension
         return largest_dimension
 
@@ -120,17 +117,6 @@ def largest_dimension(self):
     def largest_dimension(self, value):
         self._largest_dimension = value
 
-    @property
-    def tet_meshes(self):
-        values = []
-        for shape_or_component in self.shapes_and_components:
-            values.append(shape_or_component.tet_mesh)
-        return values
-
-    @tet_meshes.setter
-    def tet_meshes(self, value):
-        self._tet_meshes = value
-
     @property
     def largest_shapes(self):
         return self._largest_shapes
@@ -139,8 +125,8 @@ def largest_shapes(self):
     def largest_shapes(self, value):
         if not isinstance(value, (list, tuple, type(None))):
             raise ValueError(
-                "paramak.Reactor.largest_shapes should be a "
-                "list of paramak.Shapes")
+                "paramak.Reactor.largest_shapes should be a " "list of paramak.Shapes"
+            )
         self._largest_shapes = value
 
     @property
@@ -161,20 +147,6 @@ def shapes_and_components(self, value):
             raise ValueError("shapes_and_components must be a list")
         self._shapes_and_components = value
 
-    @property
-    def graveyard_offset(self):
-        return self._graveyard_offset
-
-    @graveyard_offset.setter
-    def graveyard_offset(self, value):
-        if value is None:
-            self._graveyard_offset = None
-        elif not isinstance(value, (float, int)):
-            raise TypeError("graveyard_offset must be a number")
-        elif value < 0:
-            raise ValueError("graveyard_offset must be positive")
-        self._graveyard_offset = value
-
     @property
     def solid(self):
         """This combines all the parametric shapes and components in the
@@ -196,6 +168,10 @@ def solid(self):
 
         return compound
 
+    @solid.setter
+    def solid(self, value):
+        self._solid = value
+
     @property
     def name(self):
         """Returns a list of names of the individual Shapes that make up the
@@ -207,10 +183,6 @@ def name(self):
 
         return all_names
 
-    @solid.setter
-    def solid(self, value):
-        self._solid = value
-
     def show(self, default_edgecolor: Tuple[float, float, float] = (0, 0, 0)):
         """Shows / renders the CadQuery the 3d object in Jupyter Lab. Imports
         show from jupyter_cadquery.cadquery and returns show(Reactor.solid)
@@ -250,11 +222,7 @@ def show(self, default_edgecolor: Tuple[float, float, float] = (0, 0, 0)):
                 (cq.occ_impl.shapes.Shape, cq.occ_impl.shapes.Compound),
             ):
                 for i, solid in enumerate(shape_or_compound.solid.Solids()):
-                    parts.append(
-                        Part(
-                            solid,
-                            name=f"{name}{i}",
-                            color=scaled_color))
+                    parts.append(Part(solid, name=f"{name}{i}", color=scaled_color))
             else:
                 parts.append(
                     Part(
@@ -305,17 +273,18 @@ def export_stp(
 
             if units == "cm":
                 _replace(
-                    filename,
-                    "SI_UNIT(.MILLI.,.METRE.)",
-                    "SI_UNIT(.CENTI.,.METRE.)")
+                    filename, "SI_UNIT(.MILLI.,.METRE.)", "SI_UNIT(.CENTI.,.METRE.)"
+                )
 
             return [filename]
 
         if filename is None:
             if None in self.name:
-                msg = ("Shape.name is None and therefore it can't be used "
-                       "to name a stp file. Try setting Shape.name for all "
-                       "shapes in the reactor")
+                msg = (
+                    "Shape.name is None and therefore it can't be used "
+                    "to name a stp file. Try setting Shape.name for all "
+                    "shapes in the reactor"
+                )
                 raise ValueError(msg)
             filename = [f"{name}.stp" for name in self.name]
 
@@ -338,9 +307,8 @@ def export_stp(
 
             if units == "cm":
                 _replace(
-                    stp_filename,
-                    "SI_UNIT(.MILLI.,.METRE.)",
-                    "SI_UNIT(.CENTI.,.METRE.)")
+                    stp_filename, "SI_UNIT(.MILLI.,.METRE.)", "SI_UNIT(.CENTI.,.METRE.)"
+                )
 
         return filename
 
@@ -364,6 +332,7 @@ def export_brep(self, filename: str, merge: bool = True):
             self.solid.exportBrep(str(path_filename))
         else:
             import OCP
+
             bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
 
             for shape in self.shapes_and_components:
@@ -386,7 +355,7 @@ def export_stl(
         filename: Union[List[str], str] = None,
         tolerance: Optional[float] = 0.001,
         angular_tolerance: Optional[float] = 0.1,
-    ) -> List[str]:
+    ) -> Union[str, List[str]]:
         """Writes stl files (CAD geometry) for each Shape object in the reactor
 
         Args:
@@ -428,9 +397,11 @@ def export_stl(
 
         if filename is None:
             if None in self.name:
-                msg = ("Shape.name is None and therefore it can't be used "
-                       "to name a stl file. Try setting Shape.name for all "
-                       "shapes in the reactor")
+                msg = (
+                    "Shape.name is None and therefore it can't be used "
+                    "to name a stl file. Try setting Shape.name for all "
+                    "shapes in the reactor"
+                )
                 raise ValueError()
             filename = [f"{name}.stl" for name in self.name]
 
@@ -579,11 +550,7 @@ def export_svg(
         if strokeWidth is not None:
             opt["strokeWidth"] = strokeWidth
 
-        exporters.export(
-            self.solid,
-            str(path_filename),
-            exportType="SVG",
-            opt=opt)
+        exporters.export(self.solid, str(path_filename), exportType="SVG", opt=opt)
 
         print("Saved file as ", path_filename)
 
@@ -731,7 +698,7 @@ def export_2d_image(
     def export_html_3d(
         self,
         filename: Optional[str] = "reactor_3d.html",
-    ) -> str:
+    ) -> Optional[str]:
         """Saves an interactive 3d html view of the Reactor to a html file.
 
         Args:
@@ -749,11 +716,7 @@ def export_html_3d(
         if view is None:
             return None
 
-        embed_minimal_html(
-            filename,
-            views=[
-                view.cq_view.renderer],
-            title="Renderer")
+        embed_minimal_html(filename, views=[view.cq_view.renderer], title="Renderer")
 
         return filename
 
@@ -793,11 +756,7 @@ def export_html(
             facet_splines=facet_splines,
             facet_circles=facet_circles,
             tolerance=tolerance,
-            title="coordinates of the "
-            + self.__class__.__name__
-            + " reactor, viewed from the "
-            + view_plane
-            + " plane",
+            title=f"coordinates of the {self.__class__.__name__} reactor, viewed from the {view_plane} plane",
             mode="lines",
         )
 
diff --git a/paramak/shape.py b/paramak/shape.py
index 42f3ba1cb..2e0476084 100644
--- a/paramak/shape.py
+++ b/paramak/shape.py
@@ -1,4 +1,3 @@
-
 import json
 import numbers
 import warnings
@@ -7,15 +6,21 @@
 from typing import List, Optional, Tuple, Union
 
 import matplotlib.pyplot as plt
-from cadquery import (Assembly, Color, Compound, Plane, Workplane, exporters,
-                      importers)
+from cadquery import Assembly, Color, Compound, Plane, Workplane, exporters, importers
 from cadquery.occ_impl import shapes
 from matplotlib.collections import PatchCollection
 from matplotlib.patches import Polygon
 
 import paramak
-from paramak.utils import (_replace, cut_solid, facet_wire, get_hash,
-                           intersect_solid, plotly_trace, union_solid)
+from paramak.utils import (
+    _replace,
+    cut_solid,
+    facet_wire,
+    get_hash,
+    intersect_solid,
+    plotly_trace,
+    union_solid,
+)
 
 
 class Shape:
@@ -47,13 +52,6 @@ class Shape:
             workplane or path_workplane if applicable. Can be set to "X", "-Y",
             "Z", etc. A custom axis can be set by setting a list of two XYZ
             floats. Defaults to None.
-        tet_mesh (str, optional): If not None, a tet mesh flag will be added to
-            the neutronics description output. Defaults to None.
-        scale (float, optional): If not None, a scale flag will be added to
-            the neutronics description output. Defaults to None.
-        surface_reflectivity (Boolean, optional): If True, a
-            surface_reflectivity flag will be added to the neutronics
-            description output. Defaults to None.
         cut (paramak.shape or list, optional): If set, the current solid will
             be cut with the provided solid or iterable in cut. Defaults to
             None.
@@ -75,14 +73,10 @@ def __init__(
         points: Union[tuple, list] = None,
         connection_type: Optional[str] = "mixed",
         name: Optional[str] = None,
-        color: Optional[Tuple[float, float, float,
-                              Optional[float]]] = (0.5, 0.5, 0.5),
+        color: Optional[Tuple[float, float, float, Optional[float]]] = (0.5, 0.5, 0.5),
         azimuth_placement_angle: Optional[Union[float, List[float]]] = 0.0,
         workplane: Optional[Union[str, Plane]] = "XZ",
         rotation_axis: Optional[str] = None,
-        tet_mesh: Optional[str] = None,
-        scale: Optional[float] = None,
-        surface_reflectivity: Optional[bool] = False,
         # TODO defining Shape types as paramak.Shape results in circular import
         cut=None,
         intersect=None,
@@ -109,9 +103,6 @@ def __init__(
         self.old_points = 0
 
         # neutronics specific properties
-        self.tet_mesh = tet_mesh
-        self.scale = scale
-        self.surface_reflectivity = surface_reflectivity
         self.graveyard_offset = graveyard_offset
         self.graveyard_size = graveyard_size
 
@@ -120,6 +111,13 @@ def __init__(
         self.wire = None
         self.render_mesh = None
 
+        # set here but only used by Sweep shapes
+        self.path_points = None
+        self.force_cross_section = None
+
+        # set here but only used by Extrude shapes
+        self.extrusion_start_offset = None
+
         self.processed_points = None
         # self.volume = None
         self.hash_value = None
@@ -230,7 +228,7 @@ def largest_dimension(self):
                     abs(bound_box.ymin),
                     abs(bound_box.zmax),
                     abs(bound_box.zmin),
-                    largest_dimension
+                    largest_dimension,
                 )
         else:
             bound_box = self.solid.val().BoundingBox()
@@ -263,14 +261,12 @@ def workplane(self, value):
                 self._workplane = value
             else:
                 raise ValueError(
-                    "Shape.workplane must be one of ",
-                    acceptable_values,
-                    " not ",
-                    value)
+                    "Shape.workplane must be one of ", acceptable_values, " not ", value
+                )
         else:
             raise TypeError(
-                "Shape.workplane must be a string or a ",
-                "cadquery.Plane object")
+                "Shape.workplane must be a string or a ", "cadquery.Plane object"
+            )
 
     @property
     def rotation_axis(self):
@@ -279,12 +275,14 @@ def rotation_axis(self):
     @rotation_axis.setter
     def rotation_axis(self, value):
         if isinstance(value, str):
-            acceptable_values = \
-                ["X", "Y", "Z", "-X", "-Y", "-Z", "+X", "+Y", "+Z"]
+            acceptable_values = ["X", "Y", "Z", "-X", "-Y", "-Z", "+X", "+Y", "+Z"]
             if value not in acceptable_values:
-                msg = "Shape.rotation_axis must be one of " + \
-                    " ".join(acceptable_values) + \
-                    " not " + value
+                msg = (
+                    "Shape.rotation_axis must be one of "
+                    + " ".join(acceptable_values)
+                    + " not "
+                    + value
+                )
                 raise ValueError(msg)
         elif isinstance(value, Iterable):
             msg = "Shape.rotation_axis must be a tuple of three floats (X, Y, Z)"
@@ -357,45 +355,23 @@ def color(self, value):
                     if not isinstance(i, (int, float)):
                         raise ValueError(
                             "Individual entries in the Shape.color must a "
-                            "number (float or int)")
+                            "number (float or int)"
+                        )
                     if i > 1 or i < 0:
                         raise ValueError(
                             "Individual entries in the Shape.color must be "
                             "between 0 and 1"
                         )
             else:
-                raise ValueError(
-                    "Shape.color must be a list or tuple of 3 or 4 floats")
+                raise ValueError("Shape.color must be a list or tuple of 3 or 4 floats")
         else:
-            raise ValueError(
-                "Shape.color must be a list or tuple")
+            raise ValueError("Shape.color must be a list or tuple")
 
         self._color = value
 
-    @property
-    def tet_mesh(self):
-        return self._tet_mesh
-
-    @tet_mesh.setter
-    def tet_mesh(self, value):
-        if value is not None and not isinstance(value, str):
-            raise ValueError("Shape.tet_mesh must be a string", value)
-        self._tet_mesh = value
-
-    @property
-    def scale(self):
-        return self._scale
-
-    @scale.setter
-    def scale(self, value):
-        if value is not None and not isinstance(value, float):
-            raise ValueError("Shape.scale must be a float", value)
-        self._scale = value
-
     @property
     def name(self):
-        """The name of the Shape, used to identify Shapes when exporting_html
-        """
+        """The name of the Shape, used to identify Shapes when exporting_html"""
         return self._name
 
     @name.setter
@@ -444,8 +420,9 @@ def points(self):
             incorrect type: only list of lists or tuples are accepted
         """
         ignored_keys = ["_points", "_points_hash_value"]
-        if hasattr(self, 'find_points') and \
-                self.points_hash_value != get_hash(self, ignored_keys):
+        if self.find_points() and self.points_hash_value != get_hash(
+            self, ignored_keys
+        ):
             self.find_points()
             self.points_hash_value = get_hash(self, ignored_keys)
 
@@ -463,57 +440,69 @@ def points(self, values_in):
 
             for value in values:
                 if not isinstance(value, (list, tuple)):
-                    msg = (f'individual points must be a tuple.{value} in of '
-                           f'type {type(value)}')
+                    msg = (
+                        f"individual points must be a tuple.{value} in of "
+                        f"type {type(value)}"
+                    )
                     raise ValueError(msg)
 
             for counter, value in enumerate(values):
-                if self.connection_type == 'mixed':
+                if self.connection_type == "mixed":
                     if len(value) != 3:
-                        if counter != len(
-                                values) - 1:  # last point doesn't need connections
+                        if (
+                            counter != len(values) - 1
+                        ):  # last point doesn't need connections
                             msg = (
-                                'individual points should contain 3 '
-                                'entries when the Shape.connection_type is '
+                                "individual points should contain 3 "
+                                "entries when the Shape.connection_type is "
                                 '"mixed". The entries should contain two '
-                                f'coordinates and a connection type. {value} '
-                                'has a length of {len(value)}')
+                                f"coordinates and a connection type. {value} "
+                                "has a length of {len(value)}"
+                            )
                             print(values)
                             raise ValueError(msg)
                 else:
                     if len(value) != 2:
-                        msg = ('individual points should contain 2 entries '
-                               'when the Shape.connection_type is '
-                               f'{self.connection_type}. The entries should '
-                               f'just contain the coordinates {value} has a '
-                               'length of {len(value)}')
+                        msg = (
+                            "individual points should contain 2 entries "
+                            "when the Shape.connection_type is "
+                            f"{self.connection_type}. The entries should "
+                            f"just contain the coordinates {value} has a "
+                            "length of {len(value)}"
+                        )
                         raise ValueError(msg)
 
                 # Checks that the XY points are numbers
                 if not isinstance(value[0], numbers.Number):
                     msg = (
-                        'The first value in the tuples that make up the '
-                        'points represents the X value and must be a number '
-                        f'{value}')
+                        "The first value in the tuples that make up the "
+                        "points represents the X value and must be a number "
+                        f"{value}"
+                    )
                     raise ValueError(msg)
                 if not isinstance(value[1], numbers.Number):
-                    msg = ('The second value in the tuples that make up the '
-                           'points represents the X value and must be a '
-                           f'number {value}')
+                    msg = (
+                        "The second value in the tuples that make up the "
+                        "points represents the X value and must be a "
+                        f"number {value}"
+                    )
                     raise ValueError(msg)
 
                 # Checks that only straight and spline are in the connections
                 # part of points
                 if len(value) == 3:
                     if value[2] not in ["straight", "spline", "circle"]:
-                        msg = ('individual connections must be either '
-                               '"straight", "circle" or "spline"')
+                        msg = (
+                            "individual connections must be either "
+                            '"straight", "circle" or "spline"'
+                        )
                         raise ValueError(msg)
 
             if len(values) > 1:
                 if values[0][:2] == values[-1][:2]:
-                    msg = ('The coordinates of the last and first points are '
-                           'the same.')
+                    msg = (
+                        "The coordinates of the last and first points are " "the same."
+                    )
                     raise ValueError(msg)
 
         self._points = values
@@ -525,8 +514,7 @@ def azimuth_placement_angle(self):
     @azimuth_placement_angle.setter
     def azimuth_placement_angle(self, value):
         error = False
-        if isinstance(value, (int, float, Iterable)) and \
-                not isinstance(value, str):
+        if isinstance(value, (int, float, Iterable)) and not isinstance(value, str):
             if isinstance(value, Iterable):
                 for i in value:
                     if not isinstance(i, (int, float)):
@@ -567,38 +555,34 @@ def show(self, default_edgecolor: Tuple[float, float, float] = (0, 0, 0)):
             from jupyter_cadquery.cadquery import Part, PartGroup, show
         except ImportError:
             msg = (
-                'To use Shape.show() you must install jupyter_cadquery. To'
+                "To use Shape.show() you must install jupyter_cadquery. To"
                 'install jupyter_cadquery type "pip install jupyter_cadquery"'
-                ' in the terminal')
+                " in the terminal"
+            )
             raise ImportError(msg)
 
         parts = []
         if self.name is None:
-            name = 'Shape.name not set'
+            name = "Shape.name not set"
         else:
             name = self.name
 
         scaled_color = [int(i * 255) for i in self.color[0:3]]
         scaled_edge_color = [int(i * 255) for i in default_edgecolor[0:3]]
-        if isinstance(
-                self.solid,
-                (shapes.Shape, shapes.Compound)):
+        if isinstance(self.solid, (shapes.Shape, shapes.Compound)):
             for i, solid in enumerate(self.solid.Solids()):
                 parts.append(
-                    Part(
-                        solid,
-                        name=f"{name}{i}",
-                        color=scaled_color,
-                        show_edges=True
-                    ))
+                    Part(solid, name=f"{name}{i}", color=scaled_color, show_edges=True)
+                )
         else:
             parts.append(
                 Part(
                     self.solid.val(),
                     name=f"{name}",
                     color=scaled_color,
-                    show_edges=True
-                ))
+                    show_edges=True,
+                )
+            )
 
         return show(PartGroup(parts), default_edgecolor=scaled_edge_color)
 
@@ -620,8 +604,7 @@ def create_solid(self) -> Workplane:
                     current_points_list.append(XZ_points[i])
                 else:
                     current_points_list.append(XZ_points[i])
-                    instructions.append(
-                        {current_linetype: current_points_list})
+                    instructions.append({current_linetype: current_points_list})
                     current_linetype = connection
                     current_points_list = [XZ_points[i]]
             instructions.append({current_linetype: current_points_list})
@@ -630,7 +613,7 @@ def create_solid(self) -> Workplane:
                 keyname = list(instructions[-1].keys())[0]
                 instructions[-1][keyname].append(XZ_points[0])
 
-            if hasattr(self, "path_points"):
+            if self.path_points:
 
                 factor = 1
                 if self.workplane in ["XZ", "YX", "ZY"]:
@@ -640,56 +623,63 @@ def create_solid(self) -> Workplane:
 
                 if self.force_cross_section:
                     for point in self.path_points[:-1]:
-                        solid = solid.workplane(offset=point[1] * factor).\
-                            center(point[0], 0).workplane()
+                        solid = (
+                            solid.workplane(offset=point[1] * factor)
+                            .center(point[0], 0)
+                            .workplane()
+                        )
                         for entry in instructions:
                             connection_type = list(entry.keys())[0]
                             if connection_type == "spline":
                                 solid = solid.spline(
-                                    listOfXYTuple=list(entry.values())[0])
+                                    listOfXYTuple=list(entry.values())[0]
+                                )
                             elif connection_type == "straight":
                                 solid = solid.polyline(list(entry.values())[0])
                             elif connection_type == "circle":
                                 p0, p1, p2 = list(entry.values())[0][:3]
-                                solid = solid.moveTo(p0[0], p0[1]).\
-                                    threePointArc(p1, p2)
+                                solid = solid.moveTo(p0[0], p0[1]).threePointArc(p1, p2)
                         solid = solid.close()
-                        solid = solid.center(-point[0], 0).\
-                            workplane(offset=-point[1] * factor)
+                        solid = solid.center(-point[0], 0).workplane(
+                            offset=-point[1] * factor
+                        )
 
                 elif self.force_cross_section is False:
-                    solid = solid.workplane(
-                        offset=self.path_points[0][1] *
-                        factor).center(
-                        self.path_points[0][0],
-                        0).workplane()
+                    solid = (
+                        solid.workplane(offset=self.path_points[0][1] * factor)
+                        .center(self.path_points[0][0], 0)
+                        .workplane()
+                    )
                     for entry in instructions:
                         connection_type = list(entry.keys())[0]
                         if connection_type == "spline":
-                            solid = solid.spline(
-                                listOfXYTuple=list(entry.values())[0])
+                            solid = solid.spline(listOfXYTuple=list(entry.values())[0])
                         elif connection_type == "straight":
                             solid = solid.polyline(list(entry.values())[0])
                         elif connection_type == "circle":
                             p0 = list(entry.values())[0][0]
                             p1 = list(entry.values())[0][1]
                             p2 = list(entry.values())[0][2]
-                            solid = solid.moveTo(
-                                p0[0], p0[1]).threePointArc(
-                                p1, p2)
-
-                    solid = solid.close().center(0, 0).\
-                        center(-self.path_points[0][0], 0).\
-                        workplane(offset=-self.path_points[0][1] * factor)
-
-                solid = solid.workplane(offset=self.path_points[-1][1] * factor).\
-                    center(self.path_points[-1][0], 0).workplane()
+                            solid = solid.moveTo(p0[0], p0[1]).threePointArc(p1, p2)
+
+                    solid = (
+                        solid.close()
+                        .center(0, 0)
+                        .center(-self.path_points[0][0], 0)
+                        .workplane(offset=-self.path_points[0][1] * factor)
+                    )
+
+                solid = (
+                    solid.workplane(offset=self.path_points[-1][1] * factor)
+                    .center(self.path_points[-1][0], 0)
+                    .workplane()
+                )
 
             else:
                 # for rotate and extrude shapes
                 solid = Workplane(self.workplane)
                 # for extrude shapes
-                if hasattr(self, "extrusion_start_offset"):
+                if self.extrusion_start_offset:
                     extrusion_offset = -self.extrusion_start_offset
                     solid = solid.workplane(offset=extrusion_offset)
 
@@ -706,9 +696,7 @@ def create_solid(self) -> Workplane:
 
         return solid
 
-    def rotate_solid(
-            self,
-            solid: Optional[Workplane]) -> Workplane:
+    def rotate_solid(self, solid: Optional[Workplane]) -> Workplane:
         # Checks if the azimuth_placement_angle is a list of angles
         if isinstance(self.azimuth_placement_angle, Iterable):
             azimuth_placement_angles = self.azimuth_placement_angle
@@ -716,11 +704,9 @@ def rotate_solid(
             azimuth_placement_angles = [self.azimuth_placement_angle]
 
         rotated_solids = []
-        # Perform seperate rotations for each angle
+        # Perform separate rotations for each angle
         for angle in azimuth_placement_angles:
-            rotated_solids.append(
-                solid.rotate(
-                    *self.get_rotation_axis()[0], angle))
+            rotated_solids.append(solid.rotate(*self.get_rotation_axis()[0], angle))
         solid = Workplane(self.workplane)
 
         # Joins the seperate solids together
@@ -754,7 +740,7 @@ def get_rotation_axis(self):
             # X, Y or Z axis
             return (
                 rotation_axis[self.rotation_axis.replace("+", "")],
-                self.rotation_axis
+                self.rotation_axis,
             )
         elif isinstance(self.rotation_axis, Iterable):
             # Custom axis
@@ -781,8 +767,7 @@ def create_limits(self) -> Tuple[float, float, float, float]:
             y_minimum, y_maximum, z_minimum, z_maximum
         """
 
-        if hasattr(self, "find_points"):
-            self.find_points()
+        self.find_points()
         if self.points is None:
             raise ValueError("No points defined for", self)
 
@@ -794,12 +779,18 @@ def create_limits(self) -> Tuple[float, float, float, float]:
 
         return self.x_min, self.x_max, self.z_min, self.z_max
 
+    def find_points(self):
+        """Calculates the shape points. Empty method which some components
+        overright when inheritting."""
+        return None
+
     def export_stl(
-            self,
-            filename: str,
-            tolerance: Optional[float] = 0.001,
-            angular_tolerance: Optional[float] = 0.1,
-            verbose: Optional[bool] = True) -> str:
+        self,
+        filename: str,
+        tolerance: Optional[float] = 0.001,
+        angular_tolerance: Optional[float] = 0.1,
+        verbose: Optional[bool] = True,
+    ) -> str:
         """Exports an stl file for the Shape.solid.
 
         Args:
@@ -815,24 +806,25 @@ def export_stl(
         path_filename = Path(filename)
 
         if path_filename.suffix != ".stl":
-            msg = f'filename should end with .stl, not {path_filename.suffix}'
+            msg = f"filename should end with .stl, not {path_filename.suffix}"
             raise ValueError(msg)
 
         path_filename.parents[0].mkdir(parents=True, exist_ok=True)
 
-        exporters.export(self.solid, str(path_filename), exportType='STL',
-                         tolerance=tolerance,
-                         angularTolerance=angular_tolerance)
+        exporters.export(
+            self.solid,
+            str(path_filename),
+            exportType="STL",
+            tolerance=tolerance,
+            angularTolerance=angular_tolerance,
+        )
 
         if verbose:
             print("Saved file as ", path_filename)
 
         return str(path_filename)
 
-    def export_brep(
-        self,
-        filename
-    ):
+    def export_brep(self, filename):
         """Exports a brep file for the Shape.solid.
 
         Args:
@@ -856,11 +848,12 @@ def export_brep(
         return str(path_filename)
 
     def export_stp(
-            self,
-            filename: str,
-            units: Optional[str] = 'mm',
-            mode: Optional[str] = 'solid',
-            verbose: Optional[bool] = True) -> str:
+        self,
+        filename: str,
+        units: Optional[str] = "mm",
+        mode: Optional[str] = "solid",
+        verbose: Optional[bool] = True,
+    ) -> str:
         """Exports an stp file for the Shape.solid.
 
         Args:
@@ -879,12 +872,12 @@ def export_stp(
         if path_filename.suffix == ".stp" or path_filename.suffix == ".step":
             pass
         else:
-            msg = f'filename should end with .stp or .step, not {path_filename.suffix}'
+            msg = f"filename should end with .stp or .step, not {path_filename.suffix}"
             raise ValueError(msg)
 
         path_filename.parents[0].mkdir(parents=True, exist_ok=True)
 
-        if mode == 'solid':
+        if mode == "solid":
 
             assembly = Assembly(name=self.name)
 
@@ -893,22 +886,26 @@ def export_stp(
             else:
                 assembly.add(self.solid, color=Color(*self.color))
 
-            assembly.save(str(path_filename), exportType='STEP')
+            assembly.save(str(path_filename), exportType="STEP")
 
             # previous method does not support colours but puts the solid in the base file level
             # exporters.export(self.solid, str(path_filename), exportType='STEP')
 
-        elif mode == 'wire':
-            exporters.export(self.wire, str(path_filename), exportType='STEP')
+        elif mode == "wire":
+            exporters.export(self.wire, str(path_filename), exportType="STEP")
         else:
-            raise ValueError("The mode argument for export_stp \
-                only accepts 'solid' or 'wire'", self)
+            raise ValueError(
+                "The mode argument for export_stp \
+                only accepts 'solid' or 'wire'",
+                self,
+            )
 
-        if units == 'cm':
+        if units == "cm":
             _replace(
-                path_filename,
-                'SI_UNIT(.MILLI.,.METRE.)',
-                'SI_UNIT(.CENTI.,.METRE.)')
+                str(path_filename),
+                "SI_UNIT(.MILLI.,.METRE.)",
+                "SI_UNIT(.CENTI.,.METRE.)",
+            )
 
         if verbose:
             print(f"Saved file as {path_filename}")
@@ -916,18 +913,19 @@ def export_stp(
         return str(path_filename)
 
     def export_svg(
-            self,
-            filename: Optional[str] = 'shape.svg',
-            projectionDir: Tuple[float, float, float] = (-1.75, 1.1, 5),
-            width: Optional[float] = 800,
-            height: Optional[float] = 800,
-            marginLeft: Optional[float] = 100,
-            marginTop: Optional[float] = 100,
-            strokeWidth: Optional[float] = None,
-            strokeColor: Optional[Tuple[int, int, int]] = (0, 0, 0),
-            hiddenColor: Optional[Tuple[int, int, int]] = (100, 100, 100),
-            showHidden: Optional[bool] = True,
-            showAxes: Optional[bool] = False) -> str:
+        self,
+        filename: Optional[str] = "shape.svg",
+        projectionDir: Tuple[float, float, float] = (-1.75, 1.1, 5),
+        width: Optional[float] = 800,
+        height: Optional[float] = 800,
+        marginLeft: Optional[float] = 100,
+        marginTop: Optional[float] = 100,
+        strokeWidth: Optional[float] = None,
+        strokeColor: Optional[Tuple[int, int, int]] = (0, 0, 0),
+        hiddenColor: Optional[Tuple[int, int, int]] = (100, 100, 100),
+        showHidden: Optional[bool] = True,
+        showAxes: Optional[bool] = False,
+    ) -> str:
         """Exports an svg file for the Reactor.solid. If the filename provided
         doesn't end with .svg it will be added.
 
@@ -977,22 +975,21 @@ def export_svg(
             "projectionDir": projectionDir,
             "strokeColor": strokeColor,
             "hiddenColor": hiddenColor,
-            "showHidden": showHidden
+            "showHidden": showHidden,
         }
 
         if strokeWidth is not None:
             opt["strokeWidth"] = strokeWidth
 
-        exporters.export(self.solid, str(path_filename), exportType='SVG',
-                         opt=opt)
+        exporters.export(self.solid, str(path_filename), exportType="SVG", opt=opt)
 
         print("Saved file as ", path_filename)
 
         return str(path_filename)
 
     def export_html_3d(
-            self,
-            filename: Optional[str] = "shape_3d.html",
+        self,
+        filename: Optional[str] = "shape_3d.html",
     ):
         """Saves an interactive 3d html view of the Shape to a html file.
 
@@ -1011,21 +1008,17 @@ def export_html_3d(
         if view is None:
             return None
 
-        embed_minimal_html(
-            filename,
-            views=[view.cq_view.renderer],
-            title='Renderer'
-        )
+        embed_minimal_html(filename, views=[view.cq_view.renderer], title="Renderer")
 
         return filename
 
     def export_html(
-            self,
-            filename: Optional[str] = "shape.html",
-            facet_splines: Optional[bool] = True,
-            facet_circles: Optional[bool] = True,
-            tolerance: Optional[float] = 1e-3,
-            view_plane: Optional[str] = None,
+        self,
+        filename: Optional[str] = "shape.html",
+        facet_splines: Optional[bool] = True,
+        facet_circles: Optional[bool] = True,
+        tolerance: Optional[float] = 1e-3,
+        view_plane: Optional[str] = None,
     ):
         """Creates a html graph representation of the points and connections
         for the Shape object. Shapes are colored by their .color property.
@@ -1068,26 +1061,22 @@ def export_html(
             facet_splines=facet_splines,
             facet_circles=facet_circles,
             tolerance=tolerance,
-            title=(f'coordinates of {self.__class__.__name__} shape, viewed '
-                   'from the {view_plane} plane')
+            title=(
+                f"coordinates of {self.__class__.__name__} shape, viewed "
+                "from the {view_plane} plane"
+            ),
         )
 
         if self.points is not None:
             fig.add_trace(
-                plotly_trace(
-                    points=self.points,
-                    mode="markers",
-                    name='Shape.points'
-                )
+                plotly_trace(points=self.points, mode="markers", name="Shape.points")
             )
 
         # sweep shapes have .path_points but not .points attribute
-        if hasattr(self, 'path_points'):
+        if self.path_points:
             fig.add_trace(
                 plotly_trace(
-                    points=self.path_points,
-                    mode="markers",
-                    name='Shape.path_points'
+                    points=self.path_points, mode="markers", name="Shape.path_points"
                 )
             )
 
@@ -1105,12 +1094,13 @@ def export_html(
         return fig
 
     def export_2d_image(
-            self,
-            filename: Optional[str] = 'shape.png',
-            xmin: Optional[float] = 0.,
-            xmax: Optional[float] = 900.,
-            ymin: Optional[float] = -600.,
-            ymax: Optional[float] = 600.):
+        self,
+        filename: Optional[str] = "shape.png",
+        xmin: Optional[float] = 0.0,
+        xmax: Optional[float] = 900.0,
+        ymin: Optional[float] = -600.0,
+        ymax: Optional[float] = 600.0,
+    ):
         """Exports a 2d image (png) of the reactor. Components are colored by
         their Shape.color property. If filename provided doesn't end with .png
         then .png will be added.
@@ -1142,7 +1132,9 @@ def export_2d_image(
 
         plt.savefig(filename, dpi=100)
         plt.close()
-        print(f'\n saved 2d image to {filename}', )
+        print(
+            f"\n saved 2d image to {filename}",
+        )
 
         return plt
 
@@ -1162,10 +1154,7 @@ def _create_patch(self):
 
         patches = []
 
-        edges = facet_wire(
-            wire=self.wire,
-            facet_splines=True,
-            facet_circles=True)
+        edges = facet_wire(wire=self.wire, facet_splines=True, facet_circles=True)
 
         fpoints = []
         for edge in edges:
@@ -1178,7 +1167,7 @@ def _create_patch(self):
         patch = PatchCollection(patches)
 
         if self.color is not None:
-            print('color is ', self.color)
+            print("color is ", self.color)
             patch.set_facecolor(self.color[0:3])
             patch.set_color(self.color[0:3])
             patch.color = self.color[0:3]
@@ -1200,9 +1189,9 @@ def perform_boolean_operations(self, solid: Workplane, **kwargs):
         # If a wedge cut is provided then perform a boolean cut
         # Performed independently to avoid use of self.cut
         # Prevents repetition of 'outdated' wedge cuts
-        if 'wedge_cut' in kwargs:
-            if kwargs['wedge_cut'] is not None:
-                solid = cut_solid(solid, kwargs['wedge_cut'])
+        if "wedge_cut" in kwargs:
+            if kwargs["wedge_cut"] is not None:
+                solid = cut_solid(solid, kwargs["wedge_cut"])
 
         # If an intersect is provided then perform a boolean intersect
         if self.intersect is not None:
@@ -1215,9 +1204,9 @@ def perform_boolean_operations(self, solid: Workplane, **kwargs):
         return solid
 
     def make_graveyard(
-            self,
-            graveyard_size: Optional[float] = None,
-            graveyard_offset: Optional[float] = None,
+        self,
+        graveyard_size: Optional[float] = None,
+        graveyard_offset: Optional[float] = None,
     ):
         """Creates a graveyard volume (bounding box) that encapsulates all
         volumes. This is required by DAGMC when performing neutronics
@@ -1252,13 +1241,16 @@ def make_graveyard(
 
         elif self.graveyard_offset is not None:
             self.solid
-            graveyard_size_to_use = self.largest_dimension * 2 + self.graveyard_offset * 2
+            graveyard_size_to_use = (
+                self.largest_dimension * 2 + self.graveyard_offset * 2
+            )
 
         else:
             raise ValueError(
                 "the graveyard_size, Shape.graveyard_size, "
                 "graveyard_offset and Shape.graveyard_offset are all None. "
-                "Please specify at least one of these attributes or arguments")
+                "Please specify at least one of these attributes or arguments"
+            )
 
         graveyard_shape = paramak.HollowCube(
             length=graveyard_size_to_use,
@@ -1270,9 +1262,10 @@ def make_graveyard(
         return graveyard_shape
 
     def export_graveyard(
-            self,
-            filename: Optional[str] = "graveyard.stp",
-            graveyard_offset: Optional[float] = 100) -> str:
+        self,
+        filename: Optional[str] = "graveyard.stp",
+        graveyard_offset: Optional[float] = 100,
+    ) -> str:
         """Writes an stp file (CAD geometry) for the reactor graveyard. This
         is needed for DAGMC simulations. This method also calls
         Reactor.make_graveyard with the offset.
@@ -1288,13 +1281,12 @@ def export_graveyard(
         """
 
         self.make_graveyard(graveyard_offset=graveyard_offset)
-        new_filename = self.graveyard.export_stp(Path(filename))
+        new_filename = self.graveyard.export_stp(str(Path(filename)))
 
         return new_filename
 
     def convert_all_circle_connections_to_splines(
-            self,
-            tolerance: Optional[float] = 0.1
+        self, tolerance: Optional[float] = 0.1
     ) -> List[Tuple[float, float, str]]:
         """Replaces circle edges in Shape.processed_points points with spline
         edges. The spline control coordinates are obtained by faceting the
@@ -1316,7 +1308,7 @@ def convert_all_circle_connections_to_splines(
         counter = 0
         while counter < len(self.processed_points):
 
-            if self.processed_points[counter][2] == 'circle':
+            if self.processed_points[counter][2] == "circle":
                 p_0 = self.processed_points[counter][:2]
                 p_1 = self.processed_points[counter + 1][:2]
                 p_2 = self.processed_points[counter + 2][:2]
@@ -1327,7 +1319,7 @@ def convert_all_circle_connections_to_splines(
 
                 # the last point needs to have the connection type of p2
                 for point in points[:-1]:
-                    new_points.append((point[0], point[1], 'spline'))
+                    new_points.append((point[0], point[1], "spline"))
 
                 new_points.append(self.processed_points[counter + 2])
                 counter = counter + 3
@@ -1353,7 +1345,7 @@ def volume(self, split_compounds=False) -> Union[float, List[float]]:
         """
 
         if not isinstance(split_compounds, bool):
-            msg = f'split_compounds must be True or False. Not {split_compounds}'
+            msg = f"split_compounds must be True or False. Not {split_compounds}"
             raise ValueError(msg)
 
         # returns a list of floats
diff --git a/paramak/utils.py b/paramak/utils.py
index a33c34065..5fd3285fc 100644
--- a/paramak/utils.py
+++ b/paramak/utils.py
@@ -1,4 +1,3 @@
-
 import math
 from collections.abc import Iterable
 from hashlib import blake2b
@@ -17,7 +16,7 @@
 import paramak
 
 
-def transform_curve(edge, tolerance: float = 1e-3):
+def transform_curve(edge, tolerance: Optional[float] = 1e-3):
     """Converts a curved edge into a series of straight lines (facetets) with
     the provided tolerance.
 
@@ -42,10 +41,10 @@ def transform_curve(edge, tolerance: float = 1e-3):
 
 
 def facet_wire(
-        wire,
-        facet_splines: bool = True,
-        facet_circles: bool = True,
-        tolerance: float = 1e-3
+    wire,
+    facet_splines: Optional[bool] = True,
+    facet_circles: Optional[bool] = True,
+    tolerance: Optional[float] = 1e-3,
 ):
     """Converts specified curved edge types from a wire into a series of
     straight lines (facetets) with the provided tol (tolerance).
@@ -67,9 +66,9 @@ def facet_wire(
 
     types_to_facet = []
     if facet_splines:
-        types_to_facet.append('BSPLINE')
+        types_to_facet.append("BSPLINE")
     if facet_circles:
-        types_to_facet.append('CIRCLE')
+        types_to_facet.append("CIRCLE")
 
     if isinstance(wire, cq.occ_impl.shapes.Edge):
         # this is for when a edge is passed
@@ -91,7 +90,8 @@ def facet_wire(
 
 
 def coefficients_of_line_from_points(
-        point_a: Tuple[float, float], point_b: Tuple[float, float]) -> Tuple[float, float]:
+    point_a: Tuple[float, float], point_b: Tuple[float, float]
+) -> Tuple[float, float]:
     """Computes the m and c coefficients of the equation (y=mx+c) for
     a straight line from two points.
 
@@ -148,8 +148,9 @@ def diff_between_angles(angle_a: float, angle_b: float) -> float:
     return delta_mod
 
 
-def distance_between_two_points(point_a: Tuple[float, float],
-                                point_b: Tuple[float, float]) -> float:
+def distance_between_two_points(
+    point_a: Tuple[float, float], point_b: Tuple[float, float]
+) -> float:
     """Computes the distance between two points.
 
     Args:
@@ -166,8 +167,9 @@ def distance_between_two_points(point_a: Tuple[float, float],
     return np.linalg.norm(u_vec)
 
 
-def extend(point_a: Tuple[float, float], point_b: Tuple[float, float],
-           L: float) -> Tuple[float, float]:
+def extend(
+    point_a: Tuple[float, float], point_b: Tuple[float, float], L: float
+) -> Tuple[float, float]:
     """Creates a point C in (ab) direction so that \\|aC\\| = L
 
     Args:
@@ -189,20 +191,19 @@ def extend(point_a: Tuple[float, float], point_b: Tuple[float, float],
 
 
 def find_center_point_of_circle(
-        point_a: Tuple[float, float],
-        point_b: Tuple[float, float],
-        point_3: Tuple[float, float]
-) -> Tuple[Tuple[float, float], float]:
+    point_a: Tuple[float, float],
+    point_b: Tuple[float, float],
+    point_3: Tuple[float, float],
+) -> Union[Tuple[float, float], None]:
     """
-    Calculates the center and the radius of a circle
-    passing through 3 points.
+    Calculates the center of a circle passing through 3 points.
     Args:
-        point_a (float, float): point 1 coordinates
-        point_b (float, float): point 2 coordinates
-        point_3 (float, float): point 3 coordinates
+        point_a: point 1 coordinates
+        point_b: point 2 coordinates
+        point_3: point 3 coordinates
     Returns:
-        (float, float), float: center of the circle coordinates or
-        None if 3 points on a line are input and the radius
+        center of the circle coordinates or None if 3 points on a line are
+        input and the radius
     """
 
     temp = point_b[0] * point_b[0] + point_b[1] * point_b[1]
@@ -213,17 +214,36 @@ def find_center_point_of_circle(
     ) * (point_a[1] - point_b[1])
 
     if abs(det) < 1.0e-6:
-        return (None, np.inf)
+        return None
 
     # Center of circle
-    cx = (bc * (point_b[1] - point_3[1]) -
-          cd * (point_a[1] - point_b[1])) / det
-    cy = ((point_a[0] - point_b[0]) * cd -
-          (point_b[0] - point_3[0]) * bc) / det
+    cx = (bc * (point_b[1] - point_3[1]) - cd * (point_a[1] - point_b[1])) / det
+    cy = ((point_a[0] - point_b[0]) * cd - (point_b[0] - point_3[0]) * bc) / det
+
+    return (cx, cy)
+
+
+def find_radius_of_circle(
+    center_point: Tuple[float, float],
+    edge_point: Tuple[float, float],
+) -> float:
+    """Calculates the radius of a circle.
 
-    radius = np.sqrt((cx - point_a[0]) ** 2 + (cy - point_a[1]) ** 2)
+    Args:
+        center_point: x, y coordinates of the center of te circle
+        edge_point: x, y coordinates of a point on the edge of the circle
+    Returns:
+        the radius of the circle
+    """
+
+    if center_point == edge_point:
+        return np.inf
+
+    radius = np.sqrt(
+        (center_point[0] - edge_point[0]) ** 2 + (center_point[1] - edge_point[1]) ** 2
+    )
 
-    return (cx, cy), radius
+    return radius
 
 
 def intersect_solid(solid, intersecter):
@@ -246,8 +266,7 @@ def intersect_solid(solid, intersecter):
     return solid
 
 
-def rotate(origin: Tuple[float, float], point: Tuple[float, float],
-           angle: float):
+def rotate(origin: Tuple[float, float], point: Tuple[float, float], angle: float):
     """
     Rotate a point counterclockwise by a given angle around a given origin.
     The angle should be given in radians.
@@ -299,8 +318,9 @@ def calculate_wedge_cut(self):
     return cutting_wedge
 
 
-def add_thickness(x: List[float], y: List[float], thickness: float,
-                  dy_dx: List[float] = None):
+def add_thickness(
+    x: List[float], y: List[float], thickness: float, dy_dx: List[float] = None
+) -> Tuple[list, list]:
     """Computes outer curve points based on thickness
 
     Args:
@@ -311,7 +331,7 @@ def add_thickness(x: List[float], y: List[float], thickness: float,
             derivatives
 
     Returns:
-        (list, list): R and Z lists for outer curve points
+        R and Z lists for outer curve points
     """
 
     if dy_dx is None:
@@ -319,9 +339,9 @@ def add_thickness(x: List[float], y: List[float], thickness: float,
 
     x_outer, y_outer = [], []
     for i in range(len(dy_dx)):
-        if dy_dx[i] == float('-inf'):
+        if dy_dx[i] == float("-inf"):
             nx, ny = -1, 0
-        elif dy_dx[i] == float('inf'):
+        elif dy_dx[i] == float("inf"):
             nx, ny = 1, 0
         else:
             nx = -dy_dx[i]
@@ -386,7 +406,7 @@ def _replace(filename: str, pattern: str, subst: str) -> None:
     """
     # Create temp file
     file_handle, abs_path = mkstemp()
-    with fdopen(file_handle, 'w') as new_file:
+    with fdopen(file_handle, "w") as new_file:
         with open(filename) as old_file:
             for line in old_file:
                 new_file.write(line.replace(pattern, subst))
@@ -402,10 +422,10 @@ def _replace(filename: str, pattern: str, subst: str) -> None:
 
 
 def plotly_trace(
-        points: Union[List[Tuple[float, float]], List[Tuple[float, float, float]]],
-        mode: str = "markers+lines",
-        name: str = None,
-        color: Union[Tuple[float, float, float], Tuple[float, float, float, float]] = None
+    points: Union[List[Tuple[float, float]], List[Tuple[float, float, float]]],
+    mode: str = "markers+lines",
+    name: str = None,
+    color: Union[Tuple[float, float, float], Tuple[float, float, float, float]] = None,
 ) -> Union[go.Scatter, go.Scatter3d]:
     """Creates a plotly trace representation of the points of the Shape
     object. This method is intended for internal use by Shape.export_html.
@@ -422,13 +442,15 @@ def plotly_trace(
         plotly trace: trace object
     """
 
-    if color is not None:
+    if color is None:
+        color_string = "rgb(125, 125, 125)"
+    else:
         color_list = [i * 255 for i in color]
 
         if len(color_list) == 3:
-            color = "rgb(" + str(color_list).strip("[]") + ")"
+            color_string = "rgb(" + str(color_list).strip("[]") + ")"
         elif len(color_list) == 4:
-            color = "rgba(" + str(color_list).strip("[]") + ")"
+            color_string = "rgba(" + str(color_list).strip("[]") + ")"
 
     if name is None:
         name = "Shape not named"
@@ -438,9 +460,9 @@ def plotly_trace(
     text_values = []
 
     for i, point in enumerate(points):
-        text = 'point number= {i} <br> x={point[0]} <br> y= {point[1]}'
+        text = "point number= {i} <br> x={point[0]} <br> y= {point[1]}"
         if len(point) == 3:
-            text = text + '<br> z= {point[2]} <br>'
+            text = text + "<br> z= {point[2]} <br>"
 
         text_values.append(text)
 
@@ -450,8 +472,8 @@ def plotly_trace(
             y=[row[1] for row in points],
             z=[row[2] for row in points],
             mode=mode,
-            marker={"size": 3, "color": color},
-            name=name
+            marker={"size": 3, "color": color_string},
+            name=name,
         )
 
         return trace
@@ -471,8 +493,8 @@ def plotly_trace(
 
 def extract_points_from_edges(
     edges: Union[List[cq.Wire], cq.Wire],
-    view_plane: str = 'XZ',
-):
+    view_plane: Optional[str] = "XZ",
+) -> list:
     """Extracts points (coordinates) from a CadQuery Edge, optionally projects
     the points to a plane and returns the points.
 
@@ -495,33 +517,31 @@ def extract_points_from_edges(
 
     for edge in list_of_edges:
         for vertex in edge.Vertices():
-            if view_plane == 'XZ':
+            if view_plane == "XZ":
                 points.append((vertex.X, vertex.Z))
-            elif view_plane == 'XY':
+            elif view_plane == "XY":
                 points.append((vertex.X, vertex.Y))
-            elif view_plane == 'YZ':
+            elif view_plane == "YZ":
                 points.append((vertex.Y, vertex.Z))
-            elif view_plane == 'YX':
+            elif view_plane == "YX":
                 points.append((vertex.Y, vertex.X))
-            elif view_plane == 'ZY':
+            elif view_plane == "ZY":
                 points.append((vertex.Z, vertex.Y))
-            elif view_plane == 'ZX':
+            elif view_plane == "ZX":
                 points.append((vertex.Z, vertex.X))
-            elif view_plane == 'RZ':
+            elif view_plane == "RZ":
                 xy_coord = math.pow(vertex.X, 2) + math.pow(vertex.Y, 2)
                 points.append((math.sqrt(xy_coord), vertex.Z))
-            elif view_plane == 'XYZ':
+            elif view_plane == "XYZ":
                 points.append((vertex.X, vertex.Y, vertex.Z))
             else:
-                raise ValueError('view_plane value of ', view_plane,
-                                 ' is not supported')
+                raise ValueError(
+                    "view_plane value of ", view_plane, " is not supported"
+                )
     return points
 
 
-def load_stp_file(
-    filename: str,
-    scale_factor: float = 1.
-):
+def load_stp_file(filename: str, scale_factor: float = 1.0):
     """Loads a stp file and makes the 3D solid and wires available for use.
 
     Args:
@@ -546,11 +566,11 @@ def load_stp_file(
 def export_wire_to_html(
     wires,
     filename=None,
-    view_plane='RZ',
-    facet_splines: bool = True,
-    facet_circles: bool = True,
-    tolerance: float = 1e-3,
-    title=None,
+    view_plane: Optional[str] = "RZ",
+    facet_splines: Optional[bool] = True,
+    facet_circles: Optional[bool] = True,
+    tolerance: Optional[float] = 1e-3,
+    title: Optional[str] = None,
     mode="markers+lines",
 ):
     """Creates a html graph representation of the points within the wires.
@@ -584,10 +604,10 @@ def export_wire_to_html(
     fig = go.Figure()
     fig.update_layout(title=title, hovermode="closest")
 
-    if view_plane == 'XYZ':
+    if view_plane == "XYZ":
         fig.update_layout(
             title=title,
-            scene_aspectmode='data',
+            scene_aspectmode="data",
             scene=dict(
                 xaxis_title=view_plane[0],
                 yaxis_title=view_plane[1],
@@ -597,10 +617,9 @@ def export_wire_to_html(
     else:
 
         fig.update_layout(
-            yaxis=dict(scaleanchor="x",
-                       scaleratio=1),
+            yaxis=dict(scaleanchor="x", scaleratio=1),
             xaxis_title=view_plane[0],
-            yaxis_title=view_plane[1]
+            yaxis_title=view_plane[1],
         )
 
     if isinstance(wires, list):
@@ -614,20 +633,15 @@ def export_wire_to_html(
             wire=wire,
             facet_splines=facet_splines,
             facet_circles=facet_circles,
-            tolerance=tolerance
+            tolerance=tolerance,
         )
 
         points = paramak.utils.extract_points_from_edges(
-            edges=edges,
-            view_plane=view_plane
+            edges=edges, view_plane=view_plane
         )
 
         fig.add_trace(
-            plotly_trace(
-                points=points,
-                mode=mode,
-                name='edge ' + str(counter)
-            )
+            plotly_trace(points=points, mode=mode, name="edge " + str(counter))
         )
 
     for counter, wire in enumerate(list_of_wires):
@@ -643,14 +657,13 @@ def export_wire_to_html(
             edges = wire.val().Edges()
 
         points = paramak.utils.extract_points_from_edges(
-            edges=edges,
-            view_plane=view_plane)
-
-        fig.add_trace(plotly_trace(
-            points=points,
-            mode="markers",
-            name='points on wire ' + str(counter)
+            edges=edges, view_plane=view_plane
         )
+
+        fig.add_trace(
+            plotly_trace(
+                points=points, mode="markers", name="points on wire " + str(counter)
+            )
         )
 
     if filename is not None:
@@ -670,10 +683,10 @@ def export_wire_to_html(
 
 
 def convert_circle_to_spline(
-        p_0: Tuple[float, float],
-        p_1: Tuple[float, float],
-        p_2: Tuple[float, float],
-        tolerance: Optional[float] = 0.1
+    p_0: Tuple[float, float],
+    p_1: Tuple[float, float],
+    p_2: Tuple[float, float],
+    tolerance: Optional[float] = 0.1,
 ) -> List[Tuple[float, float, str]]:
     """Converts three points on the edge of a circle into a series of points
     on the edge of the circle. This is done by creating a circle edge from the
@@ -691,16 +704,13 @@ def convert_circle_to_spline(
     """
 
     # work plane is arbitrarily selected and has no impact of function
-    solid = cq.Workplane('XZ').center(0, 0)
+    solid = cq.Workplane("XZ").center(0, 0)
     solid = solid.moveTo(p_0[0], p_0[1]).threePointArc(p_1, p_2)
     edge = solid.vals()[0]
 
     new_edge = paramak.utils.transform_curve(edge, tolerance=tolerance)
 
-    points = paramak.utils.extract_points_from_edges(
-        edges=new_edge,
-        view_plane='XZ'
-    )
+    points = paramak.utils.extract_points_from_edges(edges=new_edge, view_plane="XZ")
 
     return points
 
@@ -738,7 +748,10 @@ def filter(self, object_list):
             face_area = obj.Area()
 
             # Only return faces that meet the requirements
-            if face_area > self.area - self.tolerance and face_area < self.area + self.tolerance:
+            if (
+                face_area > self.area - self.tolerance
+                and face_area < self.area + self.tolerance
+            ):
                 new_obj_list.append(obj)
 
         return new_obj_list
@@ -774,14 +787,17 @@ def filter(self, object_list):
         """
 
         new_obj_list = []
-        print('filleting edge#')
+        print("filleting edge#")
         for obj in object_list:
 
             edge_len = obj.Length()
 
             # Only return edges that meet our requirements
-            if edge_len > self.length - self.tolerance and edge_len < self.length + self.tolerance:
+            if (
+                edge_len > self.length - self.tolerance
+                and edge_len < self.length + self.tolerance
+            ):
 
                 new_obj_list.append(obj)
-        print('length(new_obj_list)', len(new_obj_list))
+        print("length(new_obj_list)", len(new_obj_list))
         return new_obj_list
diff --git a/setup.py b/setup.py
index 57e25fd37..212306131 100644
--- a/setup.py
+++ b/setup.py
@@ -14,17 +14,17 @@
     url="https://github.com/fusion-energy/paramak",
     packages=setuptools.find_packages(),
     classifiers=[
-        'Natural Language :: English',
-        'Topic :: Scientific/Engineering',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: 3.9',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
+        "Natural Language :: English",
+        "Topic :: Scientific/Engineering",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
     ],
-    python_requires='>=3.6',
+    python_requires=">=3.6",
     install_requires=[
         "plotly>=5.1.0",
         "scipy>=1.7.0",
@@ -34,4 +34,5 @@
         "plasmaboundaries>=0.1.8",
         "jupyter-client<7",
         "jupyter-cadquery>=2.2.0",
-    ])
+    ],
+)


Test patch:
diff --git a/tests/local_test_examples.py b/tests/local_test_examples.py
index 9cf919873..df19cd5cc 100644
--- a/tests/local_test_examples.py
+++ b/tests/local_test_examples.py
@@ -1,12 +1,12 @@
-
 import json
 import os
 import unittest
 from pathlib import Path
 
-import paramak
 import pytest
 
+import paramak
+
 cwd = os.getcwd()
 
 "These tests require a visual front end which is not well suported on docker based CI systems"
@@ -14,7 +14,7 @@
 
 class TestLocalExamples(unittest.TestCase):
     def test_make_collarge(self):
-        """ Runs the example and checks the output files are produced"""
+        """Runs the example and checks the output files are produced"""
         os.chdir(Path(cwd))
         os.chdir(Path("examples"))
         output_filenames = [
@@ -40,7 +40,7 @@ def test_make_collarge(self):
             os.system("rm " + output_filename)
 
     def test_make_paramak_animation(self):
-        """ Runs the example and checks the output files are produced"""
+        """Runs the example and checks the output files are produced"""
         os.chdir(Path(cwd))
         os.chdir(Path("examples"))
         output_filenames = [
@@ -76,7 +76,7 @@ def test_export_3d_image(self):
         os.system("rm filename.png")
 
     def test_neutronics_cell_tally(self):
-        """ Runs the neutronics example and checks the TBR"""
+        """Runs the neutronics example and checks the TBR"""
         os.chdir(Path(cwd))
         os.chdir(Path("examples/neutronics"))
         output_filename = "simulation_result.json"
diff --git a/tests/notebook_testing.py b/tests/notebook_testing.py
index bd32ba60e..376966463 100644
--- a/tests/notebook_testing.py
+++ b/tests/notebook_testing.py
@@ -1,6 +1,5 @@
-
-import sys
 import os
+import sys
 
 import nbformat
 from nbconvert.preprocessors import ExecutePreprocessor
@@ -12,22 +11,17 @@ def notebook_run(path):
     Execute a notebook via nbconvert and collect output.
     :returns (parsed nb object, execution errors)
     """
-    kernel_name = 'python%d' % sys.version_info[0]
+    kernel_name = "python%d" % sys.version_info[0]
     this_file_directory = os.path.dirname(__file__)
     errors = []
 
     with open(path) as file:
         note_book = nbformat.read(file, as_version=4)
-        note_book.metadata.get('kernelspec', {})['name'] = kernel_name
-        ep = ExecutePreprocessor(
-            kernel_name=kernel_name,
-            timeout=800)
+        note_book.metadata.get("kernelspec", {})["name"] = kernel_name
+        ep = ExecutePreprocessor(kernel_name=kernel_name, timeout=800)
 
         try:
-            ep.preprocess(
-                note_book, {
-                    'metadata': {
-                        'path': this_file_directory}})
+            ep.preprocess(note_book, {"metadata": {"path": this_file_directory}})
 
         except CellExecutionError as e:
             if "SKIP" in e.traceback:
diff --git a/tests/test_example_components.py b/tests/test_example_components.py
index 76e92d9ca..0567c2fed 100644
--- a/tests/test_example_components.py
+++ b/tests/test_example_components.py
@@ -1,11 +1,10 @@
-
 import os
 import sys
 from pathlib import Path
 
 from notebook_testing import notebook_run
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'examples'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "examples"))
 
 
 def main():
diff --git a/tests/test_example_reactors.py b/tests/test_example_reactors.py
index 0621a437c..d3866cb66 100644
--- a/tests/test_example_reactors.py
+++ b/tests/test_example_reactors.py
@@ -1,11 +1,11 @@
-
 import os
 import sys
-from pathlib import Path
 import time
+from pathlib import Path
+
 from notebook_testing import notebook_run
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'examples'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "examples"))
 
 
 def main():
diff --git a/tests/test_example_shapes.py b/tests/test_example_shapes.py
index c47a2270b..fde87eed7 100644
--- a/tests/test_example_shapes.py
+++ b/tests/test_example_shapes.py
@@ -1,11 +1,10 @@
-
 import os
 import sys
 from pathlib import Path
 
 from notebook_testing import notebook_run
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'examples'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "examples"))
 
 
 def main():
diff --git a/tests/test_parametric_components/test_CuttingWedge.py b/tests/test_parametric_components/test_CuttingWedge.py
index 138f4f6db..ef086a345 100644
--- a/tests/test_parametric_components/test_CuttingWedge.py
+++ b/tests/test_parametric_components/test_CuttingWedge.py
@@ -1,27 +1,27 @@
-
 import math
 import random
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestCuttingWedge(unittest.TestCase):
     """Creates a random sized cutting wedge and changes the volume"""
 
     def test_volume_of_for_5_random_dimentions(self):
         for test_number in range(5):
-            height = random.uniform(1., 2000.)
-            radius = random.uniform(1., 1000)
-            rotation_angle = random.uniform(1., 360.)
-            azimuth_placement_angle = random.uniform(1., 360.)
+            height = random.uniform(1.0, 2000.0)
+            radius = random.uniform(1.0, 1000)
+            rotation_angle = random.uniform(1.0, 360.0)
+            azimuth_placement_angle = random.uniform(1.0, 360.0)
 
             test_shape = paramak.CuttingWedge(
                 height=height,
                 radius=radius,
                 rotation_angle=rotation_angle,
-                azimuth_placement_angle=azimuth_placement_angle
+                azimuth_placement_angle=azimuth_placement_angle,
             )
             angle_fraction = 360 / rotation_angle
             correct_volume = (math.pi * radius ** 2 * height) / angle_fraction
diff --git a/tests/test_parametric_components/test_blanket_constant_thickness_arch.py b/tests/test_parametric_components/test_blanket_constant_thickness_arch.py
index 9057452d3..9e4f23086 100644
--- a/tests/test_parametric_components/test_blanket_constant_thickness_arch.py
+++ b/tests/test_parametric_components/test_blanket_constant_thickness_arch.py
@@ -1,12 +1,11 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestBlanketConstantThicknessArcH(unittest.TestCase):
 
+class TestBlanketConstantThicknessArcH(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.BlanketConstantThicknessArcH(
             inner_lower_point=(300, -200),
@@ -25,12 +24,12 @@ def test_points_calculation(self):
         are calculated correctly from the parameters given."""
 
         assert self.test_shape.points == [
-            (300, 200, 'circle'),
-            (500, 0, 'circle'),
-            (300, -200, 'straight'),
-            (320, -200, 'circle'),
-            (520, 0, 'circle'),
-            (320, 200, 'straight')
+            (300, 200, "circle"),
+            (500, 0, "circle"),
+            (300, -200, "straight"),
+            (320, -200, "circle"),
+            (520, 0, "circle"),
+            (320, 200, "straight"),
         ]
 
     def test_processed_points_calculation(self):
@@ -39,13 +38,13 @@ def test_processed_points_calculation(self):
         the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (300, 200, 'circle'),
-            (500, 0, 'circle'),
-            (300, -200, 'straight'),
-            (320, -200, 'circle'),
-            (520, 0, 'circle'),
-            (320, 200, 'straight'),
-            (300, 200, 'circle')
+            (300, 200, "circle"),
+            (500, 0, "circle"),
+            (300, -200, "straight"),
+            (320, -200, "circle"),
+            (520, 0, "circle"),
+            (320, 200, "straight"),
+            (300, 200, "circle"),
         ]
 
     def test_component_creation(self):
diff --git a/tests/test_parametric_components/test_blanket_constant_thickness_arcv.py b/tests/test_parametric_components/test_blanket_constant_thickness_arcv.py
index 1121ca45d..f9eefd27c 100644
--- a/tests/test_parametric_components/test_blanket_constant_thickness_arcv.py
+++ b/tests/test_parametric_components/test_blanket_constant_thickness_arcv.py
@@ -1,12 +1,11 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestBlanketConstantThicknessArcV(unittest.TestCase):
 
+class TestBlanketConstantThicknessArcV(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.BlanketConstantThicknessArcV(
             inner_lower_point=(300, -200),
@@ -26,12 +25,12 @@ def test_points_calculation(self):
         the parameters given."""
 
         assert self.test_shape.points == [
-            (300, 200, 'circle'),
-            (500, 0, 'circle'),
-            (300, -200, 'straight'),
-            (300, -220, 'circle'),
-            (520, 0, 'circle'),
-            (300, 220, 'straight')
+            (300, 200, "circle"),
+            (500, 0, "circle"),
+            (300, -200, "straight"),
+            (300, -220, "circle"),
+            (520, 0, "circle"),
+            (300, 220, "straight"),
         ]
 
     def test_processed_points_calculation(self):
@@ -40,13 +39,13 @@ def test_processed_points_calculation(self):
         the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (300, 200, 'circle'),
-            (500, 0, 'circle'),
-            (300, -200, 'straight'),
-            (300, -220, 'circle'),
-            (520, 0, 'circle'),
-            (300, 220, 'straight'),
-            (300, 200, 'circle'),
+            (300, 200, "circle"),
+            (500, 0, "circle"),
+            (300, -200, "straight"),
+            (300, -220, "circle"),
+            (520, 0, "circle"),
+            (300, 220, "straight"),
+            (300, 200, "circle"),
         ]
 
     def test_component_creation(self):
diff --git a/tests/test_parametric_components/test_blanket_cutter_parallels.py b/tests/test_parametric_components/test_blanket_cutter_parallels.py
index 1990bf5db..bbe4f3486 100644
--- a/tests/test_parametric_components/test_blanket_cutter_parallels.py
+++ b/tests/test_parametric_components/test_blanket_cutter_parallels.py
@@ -1,22 +1,27 @@
-
 import unittest
 
 import paramak
 
 
 class TestBlanketCutterParallels(unittest.TestCase):
-
     def setUp(self):
-        self.test_shape = paramak.BlanketCutterParallels(
-            thickness=50,
-            gap_size=200
-        )
+        self.test_shape = paramak.BlanketCutterParallels(thickness=50, gap_size=200)
 
     def test_default_parameters(self):
         """Checks that the default parameters of a BlanketCutterParallel are correct."""
 
         assert self.test_shape.azimuth_placement_angle == [
-            0., 36., 72., 108., 144., 180., 216., 252., 288., 324.]
+            0.0,
+            36.0,
+            72.0,
+            108.0,
+            144.0,
+            180.0,
+            216.0,
+            252.0,
+            288.0,
+            324.0,
+        ]
         assert self.test_shape.height == 2000
         assert self.test_shape.width == 2000
 
@@ -65,4 +70,7 @@ def test_main_cutting_shape_is_modified(self):
             test_shape.gap_size = gap_size
             test_shape.azimuth_placement_angle = angles
             assert test_shape.main_cutting_shape.distance == test_shape.gap_size / 2.0
-            assert test_shape.main_cutting_shape.azimuth_placement_angle == test_shape.azimuth_placement_angle
+            assert (
+                test_shape.main_cutting_shape.azimuth_placement_angle
+                == test_shape.azimuth_placement_angle
+            )
diff --git a/tests/test_parametric_components/test_blanket_cutter_star.py b/tests/test_parametric_components/test_blanket_cutter_star.py
index d056d18b8..c9c790dfe 100644
--- a/tests/test_parametric_components/test_blanket_cutter_star.py
+++ b/tests/test_parametric_components/test_blanket_cutter_star.py
@@ -1,12 +1,11 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestBlanketCutterStar(unittest.TestCase):
 
+class TestBlanketCutterStar(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.BlanketCutterStar(distance=100)
 
@@ -14,7 +13,17 @@ def test_default_parameters(self):
         """Checks that the default parameters of a BlanketCutterStar are correct."""
 
         assert self.test_shape.azimuth_placement_angle == [
-            0., 36., 72., 108., 144., 180., 216., 252., 288., 324.]
+            0.0,
+            36.0,
+            72.0,
+            108.0,
+            144.0,
+            180.0,
+            216.0,
+            252.0,
+            288.0,
+            324.0,
+        ]
         assert self.test_shape.height == 2000
         assert self.test_shape.width == 2000
         assert self.test_shape.name == "blanket_cutter_star"
@@ -39,7 +48,7 @@ def test_processed_points_calculation(self):
             (2000, -1000, "straight"),
             (2000, 1000, "straight"),
             (0, 1000, "straight"),
-            (0, -1000, "straight")
+            (0, -1000, "straight"),
         ]
 
     def test_creation(self):
@@ -57,5 +66,4 @@ def test_distance_volume_impact(self):
         test_volume = self.test_shape.volume()
         self.test_shape.distance = 50
         # not quite two times as large as there is overlap in the center
-        assert test_volume == pytest.approx(
-            self.test_shape.volume() * 2, rel=0.1)
+        assert test_volume == pytest.approx(self.test_shape.volume() * 2, rel=0.1)
diff --git a/tests/test_parametric_components/test_blanket_fp.py b/tests/test_parametric_components/test_blanket_fp.py
index 6d0f8d998..e5a21613c 100644
--- a/tests/test_parametric_components/test_blanket_fp.py
+++ b/tests/test_parametric_components/test_blanket_fp.py
@@ -1,4 +1,3 @@
-
 import os
 import unittest
 import warnings
@@ -8,13 +7,9 @@
 
 
 class TestBlanketFP(unittest.TestCase):
-
     def setUp(self):
         self.plasma = paramak.Plasma(
-            major_radius=450,
-            minor_radius=150,
-            triangularity=0.55,
-            elongation=2
+            major_radius=450, minor_radius=150, triangularity=0.55, elongation=2
         )
 
         self.test_shape = paramak.BlanketFP(
@@ -126,8 +121,7 @@ def test_creation_variable_offset_error(self):
         def test_different_lengths():
             self.test_shape.start_angle = 90
             self.test_shape.stop_angle = 270
-            self.test_shape.offset_from_plasma = [
-                [270, 100, 90], [0, 5, 10, 15]]
+            self.test_shape.offset_from_plasma = [[270, 100, 90], [0, 5, 10, 15]]
             self.test_shape.solid
 
         self.assertRaises(ValueError, test_different_lengths)
@@ -171,8 +165,7 @@ def test_full_cov_full_rotation(self):
         os.system("rm test_blanket_full_cov_full_rot.stp")
 
     def test_overlapping(self):
-        """Creates an overlapping geometry and checks that a warning is raised.
-        """
+        """Creates an overlapping geometry and checks that a warning is raised."""
 
         test_shape = paramak.BlanketFP(
             major_radius=100,
@@ -189,5 +182,4 @@ def test_overlapping(self):
             for a in w:
                 print(a.message)
             assert test_shape.solid is not None
-            assert "BlanketFP: Some points with negative R" in str(
-                w[0].message)
+            assert "BlanketFP: Some points with negative R" in str(w[0].message)
diff --git a/tests/test_parametric_components/test_capsule_vacuum_vessel.py b/tests/test_parametric_components/test_capsule_vacuum_vessel.py
index 0b67e498f..ac4891083 100644
--- a/tests/test_parametric_components/test_capsule_vacuum_vessel.py
+++ b/tests/test_parametric_components/test_capsule_vacuum_vessel.py
@@ -1,16 +1,16 @@
-import pytest
 import math
+
+import pytest
+
 import paramak
 
-'''This test evaluates the perimeter of the resultant points and asserts them agaist the known value'''
+"""This test evaluates the perimeter of the resultant points and asserts them agaist the known value"""
 
 
 def perimeter(outer_start_point, radius, thickness):
 
     test_shape = paramak.CapsuleVacuumVessel(
-        outer_start_point=outer_start_point,
-        radius=radius,
-        thickness=thickness
+        outer_start_point=outer_start_point, radius=radius, thickness=thickness
     )
     point1 = test_shape.points[0]
     point2 = test_shape.points[1]
@@ -25,14 +25,12 @@ def perimeter(outer_start_point, radius, thickness):
     point11 = test_shape.points[10]
     point12 = test_shape.points[11]
 
-    straightedges = float((point12[1] -
-                           point1[1]) +
-                          (point6[1] -
-                           point7[1]) +
-                          (point4[1] -
-                           point3[1]) +
-                          (point9[1] -
-                           point10[1]))
+    straightedges = float(
+        (point12[1] - point1[1])
+        + (point6[1] - point7[1])
+        + (point4[1] - point3[1])
+        + (point9[1] - point10[1])
+    )
     curvededges = float((math.pi * radius) + (math.pi * (radius - thickness)))
     total = float(straightedges + curvededges)
 
@@ -40,35 +38,25 @@ def perimeter(outer_start_point, radius, thickness):
 
 
 def test_perimeter1():
-    testp = perimeter(
-        outer_start_point=(0, 0),
-        radius=300,
-        thickness=10)
+    testp = perimeter(outer_start_point=(0, 0), radius=300, thickness=10)
     assert testp == pytest.approx(3073.54)
 
 
 def test_perimeter2():
-    testp = perimeter(
-        outer_start_point=(100, -100),
-        radius=400,
-        thickness=25)
+    testp = perimeter(outer_start_point=(100, -100), radius=400, thickness=25)
     assert testp == pytest.approx(4084.734)
 
 
 def test_perimeter3():
-    testp = perimeter(
-        outer_start_point=(1000, -500),
-        radius=5000,
-        thickness=50)
+    testp = perimeter(outer_start_point=(1000, -500), radius=5000, thickness=50)
     assert testp == pytest.approx(51358.85)
 
 
 def test_pointnum1():
     """this tests if the number of points returned are correct"""
     shape = paramak.CapsuleVacuumVessel(
-        outer_start_point=(0, 0),
-        radius=300,
-        thickness=10)
+        outer_start_point=(0, 0), radius=300, thickness=10
+    )
     assert len(shape.points) == 12
     assert len(shape.processed_points) == 13
 
@@ -76,9 +64,8 @@ def test_pointnum1():
 def test_pointnum2():
     """this tests if the number of points returned are correct"""
     shape = paramak.CapsuleVacuumVessel(
-        outer_start_point=(100, -100),
-        radius=400,
-        thickness=25)
+        outer_start_point=(100, -100), radius=400, thickness=25
+    )
     assert len(shape.points) == 12
     assert len(shape.processed_points) == 13
 
@@ -86,14 +73,13 @@ def test_pointnum2():
 def test_pointnum3():
     """this tests if the number of points returned are correct"""
     shape = paramak.CapsuleVacuumVessel(
-        outer_start_point=(1000, -500),
-        radius=5000,
-        thickness=50)
+        outer_start_point=(1000, -500), radius=5000, thickness=50
+    )
     assert len(shape.points) == 12
     assert len(shape.processed_points) == 13
 
 
-'''this tests the volume of the created component and asserts it agaist the known value'''
+"""this tests the volume of the created component and asserts it agaist the known value"""
 
 
 def volume(outer_start_point, radius, thickness, angle):
@@ -102,7 +88,7 @@ def volume(outer_start_point, radius, thickness, angle):
         outer_start_point=outer_start_point,
         radius=radius,
         thickness=thickness,
-        rotation_angle=angle
+        rotation_angle=angle,
     )
 
     point3 = test_shape.points[2]
@@ -111,12 +97,12 @@ def volume(outer_start_point, radius, thickness, angle):
     point9 = test_shape.points[8]
     point10 = test_shape.points[9]
 
-    outer_volume_cylinder = float(
-        math.pi * (radius**2) * (point4[1] - point3[1]))
+    outer_volume_cylinder = float(math.pi * (radius ** 2) * (point4[1] - point3[1]))
     inner_volume_cylinder = float(
-        math.pi * ((radius - thickness)**2) * (point9[1] - point10[1]))
-    outer_volume_sphere = float((4 / 3) * math.pi * (radius**3))
-    inner_volume_sphere = float((4 / 3) * math.pi * ((radius - thickness)**3))
+        math.pi * ((radius - thickness) ** 2) * (point9[1] - point10[1])
+    )
+    outer_volume_sphere = float((4 / 3) * math.pi * (radius ** 3))
+    inner_volume_sphere = float((4 / 3) * math.pi * ((radius - thickness) ** 3))
     outer_volume = outer_volume_sphere + outer_volume_cylinder
     inner_volume = inner_volume_cylinder + inner_volume_sphere
     total_volume = (angle / 360) * (outer_volume - inner_volume)
@@ -125,27 +111,17 @@ def volume(outer_start_point, radius, thickness, angle):
 
 
 def testvolume1():
-    testvol = volume(
-        outer_start_point=(0, 0),
-        radius=300,
-        thickness=10,
-        angle=180)
+    testvol = volume(outer_start_point=(0, 0), radius=300, thickness=10, angle=180)
     assert testvol == pytest.approx(11029084.61)
 
 
 def testvolume2():
-    testvol = volume(
-        outer_start_point=(100, -100),
-        radius=400,
-        thickness=25,
-        angle=360)
+    testvol = volume(outer_start_point=(100, -100), radius=400, thickness=25, angle=360)
     assert testvol == pytest.approx(95884025.78)
 
 
 def testvolume3():
     testvol = volume(
-        outer_start_point=(1000, -500),
-        radius=5000,
-        thickness=50,
-        angle=90)
+        outer_start_point=(1000, -500), radius=5000, thickness=50, angle=90
+    )
     assert testvol == pytest.approx(7795207671.41)
diff --git a/tests/test_parametric_components/test_center_column_shield_circular.py b/tests/test_parametric_components/test_center_column_shield_circular.py
index 8492ccc79..505a9ba19 100644
--- a/tests/test_parametric_components/test_center_column_shield_circular.py
+++ b/tests/test_parametric_components/test_center_column_shield_circular.py
@@ -1,11 +1,9 @@
-
 import unittest
 
 import paramak
 
 
 class TestCenterColumnShieldCircular(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldCircular(
             height=600, inner_radius=100, mid_radius=150, outer_radius=200
@@ -21,12 +19,12 @@ def test_points_calculation(self):
         are calculated correctly from the parameters given."""
 
         assert self.test_shape.points == [
-            (100, 0, 'straight'),
-            (100, 300.0, 'straight'),
-            (200, 300.0, 'circle'),
-            (150, 0, 'circle'),
-            (200, -300.0, 'straight'),
-            (100, -300.0, 'straight'),
+            (100, 0, "straight"),
+            (100, 300.0, "straight"),
+            (200, 300.0, "circle"),
+            (150, 0, "circle"),
+            (200, -300.0, "straight"),
+            (100, -300.0, "straight"),
         ]
 
     def test_processed_points_calculation(self):
@@ -34,13 +32,13 @@ def test_processed_points_calculation(self):
         are calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (100, 0, 'straight'),
-            (100, 300.0, 'straight'),
-            (200, 300.0, 'circle'),
-            (150, 0, 'circle'),
-            (200, -300.0, 'straight'),
-            (100, -300.0, 'straight'),
-            (100, 0, 'straight')
+            (100, 0, "straight"),
+            (100, 300.0, "straight"),
+            (200, 300.0, "circle"),
+            (150, 0, "circle"),
+            (200, -300.0, "straight"),
+            (100, -300.0, "straight"),
+            (100, 0, "straight"),
         ]
 
     def test_creation(self):
diff --git a/tests/test_parametric_components/test_center_column_shield_cylinder.py b/tests/test_parametric_components/test_center_column_shield_cylinder.py
index 15b2f4ae0..fd787ecc6 100644
--- a/tests/test_parametric_components/test_center_column_shield_cylinder.py
+++ b/tests/test_parametric_components/test_center_column_shield_cylinder.py
@@ -1,15 +1,14 @@
-
 import math
 import os
 import unittest
 from pathlib import Path
 
-import paramak
 import pytest
 
+import paramak
 
-class TestCenterColumnShieldCylinder(unittest.TestCase):
 
+class TestCenterColumnShieldCylinder(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldCylinder(
             height=600, inner_radius=100, outer_radius=200
@@ -37,7 +36,7 @@ def test_processed_points_calculation(self):
             (200, 300, "straight"),
             (200, -300, "straight"),
             (100, -300, "straight"),
-            (100, 300, "straight")
+            (100, 300, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -65,7 +64,7 @@ def test_absolute_volume(self):
         relative volume is correct"""
 
         assert self.test_shape.volume() == pytest.approx(
-            ((math.pi * (200**2)) - (math.pi * (100**2))) * 600
+            ((math.pi * (200 ** 2)) - (math.pi * (100 ** 2))) * 600
         )
 
     def test_absolute_area(self):
@@ -73,14 +72,23 @@ def test_absolute_area(self):
         areas of the faces of the solid created are correct"""
 
         assert len(self.test_shape.areas) == 4
-        assert self.test_shape.area == pytest.approx((((math.pi * (200**2)) - (math.pi * (
-            100**2))) * 2) + (math.pi * (2 * 200) * 600) + (math.pi * (2 * 100) * 600))
-        assert self.test_shape.areas.count(pytest.approx(
-            (math.pi * (200**2)) - (math.pi * (100**2)))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (2 * 200) * 600)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (2 * 100) * 600)) == 1
+        assert self.test_shape.area == pytest.approx(
+            (((math.pi * (200 ** 2)) - (math.pi * (100 ** 2))) * 2)
+            + (math.pi * (2 * 200) * 600)
+            + (math.pi * (2 * 100) * 600)
+        )
+        assert (
+            self.test_shape.areas.count(
+                pytest.approx((math.pi * (200 ** 2)) - (math.pi * (100 ** 2)))
+            )
+            == 2
+        )
+        assert (
+            self.test_shape.areas.count(pytest.approx(math.pi * (2 * 200) * 600)) == 1
+        )
+        assert (
+            self.test_shape.areas.count(pytest.approx(math.pi * (2 * 100) * 600)) == 1
+        )
 
     def test_export_stp_CenterColumnShieldCylinder(self):
         """Creates a CenterColumnShieldCylinder shape and checks that a stp
@@ -129,7 +137,7 @@ def incorrect_height():
             self.test_shape.height = None
 
         def incorrect_center_height():
-            self.test_shape.center_height = 'string'
+            self.test_shape.center_height = "string"
 
         def incorrect_center_height_none():
             self.test_shape.center_height = None
@@ -145,10 +153,7 @@ def test_center_height_usage(self):
         the default center_height=0 shape. Cuts shapes and checks volumes.
         """
         test_shape1 = paramak.CenterColumnShieldCylinder(
-            inner_radius=3,
-            outer_radius=3.3,
-            height=5,
-            color=(1, 0, 0)
+            inner_radius=3, outer_radius=3.3, height=5, color=(1, 0, 0)
         )
 
         test_shape2 = paramak.CenterColumnShieldCylinder(
@@ -156,7 +161,7 @@ def test_center_height_usage(self):
             outer_radius=3.3,
             height=5,
             center_height=-2.5,
-            color=(1, 0, 0)
+            color=(1, 0, 0),
         )
 
         test_shape3 = paramak.CenterColumnShieldCylinder(
@@ -165,9 +170,8 @@ def test_center_height_usage(self):
             height=5,
             center_height=0,
             color=(1, 0, 0),
-            cut=test_shape2
+            cut=test_shape2,
         )
 
         assert test_shape2.volume() == test_shape1.volume()
-        assert pytest.approx(test_shape3.volume()) == 0.5 * \
-            test_shape1.volume()
+        assert pytest.approx(test_shape3.volume()) == 0.5 * test_shape1.volume()
diff --git a/tests/test_parametric_components/test_center_column_shield_flat_top_circular.py b/tests/test_parametric_components/test_center_column_shield_flat_top_circular.py
index f755fc5b7..1428fe693 100644
--- a/tests/test_parametric_components/test_center_column_shield_flat_top_circular.py
+++ b/tests/test_parametric_components/test_center_column_shield_flat_top_circular.py
@@ -1,14 +1,17 @@
-
 import unittest
 
 import paramak
 
 
 class TestCenterColumnShieldFlatTopCircular(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldFlatTopCircular(
-            height=600, arc_height=400, inner_radius=100, mid_radius=150, outer_radius=200)
+            height=600,
+            arc_height=400,
+            inner_radius=100,
+            mid_radius=150,
+            outer_radius=200,
+        )
 
     def test_default_parameters(self):
         """Checks that the default parameters of a CenterColumnShieldFlatTopCircular are
@@ -45,7 +48,7 @@ def test_processed_points_calculation(self):
             (200, -200, "straight"),
             (200, -300, "straight"),
             (100, -300, "straight"),
-            (100, 0, "straight")
+            (100, 0, "straight"),
         ]
 
     def test_creation(self):
diff --git a/tests/test_parametric_components/test_center_column_shield_flat_top_hyperbola.py b/tests/test_parametric_components/test_center_column_shield_flat_top_hyperbola.py
index 62849e743..16a5dd553 100644
--- a/tests/test_parametric_components/test_center_column_shield_flat_top_hyperbola.py
+++ b/tests/test_parametric_components/test_center_column_shield_flat_top_hyperbola.py
@@ -1,14 +1,17 @@
-
 import unittest
 
 import paramak
 
 
 class TestCenterColumnShieldFlatTopHyperbola(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldFlatTopHyperbola(
-            height=600, arc_height=400, inner_radius=100, mid_radius=150, outer_radius=200)
+            height=600,
+            arc_height=400,
+            inner_radius=100,
+            mid_radius=150,
+            outer_radius=200,
+        )
 
     def test_default_parameters(self):
         """Checks that the default parameters of a CenterColumnShieldFlatTopHyperbola are
@@ -46,7 +49,7 @@ def test_processed_points_calculation(self):
             (200, -200, "straight"),
             (200, -300, "straight"),
             (100, -300, "straight"),
-            (100, 0, "straight")
+            (100, 0, "straight"),
         ]
 
     def test_creation(self):
diff --git a/tests/test_parametric_components/test_center_column_shield_hyperbola.py b/tests/test_parametric_components/test_center_column_shield_hyperbola.py
index e7397f317..fa3fb1705 100644
--- a/tests/test_parametric_components/test_center_column_shield_hyperbola.py
+++ b/tests/test_parametric_components/test_center_column_shield_hyperbola.py
@@ -1,11 +1,9 @@
-
 import unittest
 
 import paramak
 
 
 class TestCenterColumnShieldHyperbola(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldHyperbola(
             height=600, inner_radius=100, mid_radius=150, outer_radius=200
@@ -29,7 +27,7 @@ def test_processed_points_calculation(self):
             (150.0, 0.0, "spline"),
             (200.0, -300.0, "straight"),
             (100.0, -300.0, "straight"),
-            (100.0, 0.0, "straight")
+            (100.0, 0.0, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -43,7 +41,7 @@ def test_points_calculation(self):
             (200.0, 300.0, "spline"),
             (150.0, 0.0, "spline"),
             (200.0, -300.0, "straight"),
-            (100.0, -300.0, "straight")
+            (100.0, -300.0, "straight"),
         ]
 
     def test_creation(self):
diff --git a/tests/test_parametric_components/test_center_column_shield_plasma_hyperbola.py b/tests/test_parametric_components/test_center_column_shield_plasma_hyperbola.py
index e0a086599..4003ed81c 100644
--- a/tests/test_parametric_components/test_center_column_shield_plasma_hyperbola.py
+++ b/tests/test_parametric_components/test_center_column_shield_plasma_hyperbola.py
@@ -1,11 +1,9 @@
-
 import unittest
 
 import paramak
 
 
 class TestCenterColumnShieldPlasmaHyperbola(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CenterColumnShieldPlasmaHyperbola(
             height=800, inner_radius=100, mid_offset=40, edge_offset=30
@@ -35,14 +33,14 @@ def test_points_calculation(self):
         from the parameters given."""
 
         assert self.test_shape.points == [
-            (100, 0, 'straight'),
-            (100, 400.0, 'straight'),
-            (337.5, 400.0, 'straight'),
-            (337.5, 300.0, 'spline'),
-            (260.0, 0.0, 'spline'),
-            (337.5, -300.0, 'straight'),
-            (337.5, -400.0, 'straight'),
-            (100, -400.0, 'straight'),
+            (100, 0, "straight"),
+            (100, 400.0, "straight"),
+            (337.5, 400.0, "straight"),
+            (337.5, 300.0, "spline"),
+            (260.0, 0.0, "spline"),
+            (337.5, -300.0, "straight"),
+            (337.5, -400.0, "straight"),
+            (100, -400.0, "straight"),
         ]
 
     def test_processed_points_calculation(self):
@@ -51,15 +49,15 @@ def test_processed_points_calculation(self):
         from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (100, 0, 'straight'),
-            (100, 400.0, 'straight'),
-            (337.5, 400.0, 'straight'),
-            (337.5, 300.0, 'spline'),
-            (260.0, 0.0, 'spline'),
-            (337.5, -300.0, 'straight'),
-            (337.5, -400.0, 'straight'),
-            (100, -400.0, 'straight'),
-            (100, 0, 'straight')
+            (100, 0, "straight"),
+            (100, 400.0, "straight"),
+            (337.5, 400.0, "straight"),
+            (337.5, 300.0, "spline"),
+            (260.0, 0.0, "spline"),
+            (337.5, -300.0, "straight"),
+            (337.5, -400.0, "straight"),
+            (100, -400.0, "straight"),
+            (100, 0, "straight"),
         ]
 
     def test_invalid_parameters_errors(self):
diff --git a/tests/test_parametric_components/test_coolant_channel_ring_curved.py b/tests/test_parametric_components/test_coolant_channel_ring_curved.py
index 99e9294c6..028473376 100644
--- a/tests/test_parametric_components/test_coolant_channel_ring_curved.py
+++ b/tests/test_parametric_components/test_coolant_channel_ring_curved.py
@@ -1,19 +1,18 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestCoolantChannelRingCurved(unittest.TestCase):
 
+class TestCoolantChannelRingCurved(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.CoolantChannelRingCurved(
             height=100,
             channel_radius=10,
             ring_radius=70,
             mid_offset=-20,
-            number_of_coolant_channels=6
+            number_of_coolant_channels=6,
         )
 
     def test_default_parameters(self):
@@ -47,10 +46,6 @@ def test_start_angle(self):
         """Checks that the coolant channels are placed at the correct azimuthal placement
         angles for a given start angle."""
 
-        assert self.test_shape.azimuth_placement_angle == [
-            0, 60, 120, 180, 240, 300
-        ]
+        assert self.test_shape.azimuth_placement_angle == [0, 60, 120, 180, 240, 300]
         self.test_shape.start_angle = 10
-        assert self.test_shape.azimuth_placement_angle == [
-            10, 70, 130, 190, 250, 310
-        ]
+        assert self.test_shape.azimuth_placement_angle == [10, 70, 130, 190, 250, 310]
diff --git a/tests/test_parametric_components/test_coolant_channel_ring_straight.py b/tests/test_parametric_components/test_coolant_channel_ring_straight.py
index 96e6512e2..dd316f5e3 100644
--- a/tests/test_parametric_components/test_coolant_channel_ring_straight.py
+++ b/tests/test_parametric_components/test_coolant_channel_ring_straight.py
@@ -1,19 +1,15 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestCoolantChannelRingStraight(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.CoolantChannelRingStraight(
-            height=100,
-            channel_radius=10,
-            ring_radius=70,
-            number_of_coolant_channels=8
+            height=100, channel_radius=10, ring_radius=70, number_of_coolant_channels=8
         )
 
     def test_default_parameters(self):
@@ -37,12 +33,11 @@ def test_faces(self):
         self.test_shape.rotation_axis = "Z"
 
         assert self.test_shape.area == pytest.approx(
-            (((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * 100)) * 8)
+            (((math.pi * (10 ** 2)) * 2) + (math.pi * (10 * 2) * 100)) * 8
+        )
         assert len(self.test_shape.areas) == 24
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2))) == 16
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10 * 2) * 100)) == 8
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2))) == 16
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (10 * 2) * 100)) == 8
 
     def test_volume(self):
         """Creates CoolantChannelRingStraight shapes and checks that the volumes are correct."""
@@ -50,17 +45,30 @@ def test_volume(self):
         self.test_shape.workplane = "XY"
         self.test_shape.rotation_axis = "Z"
 
-        assert self.test_shape.volume() == pytest.approx(
-            math.pi * (10 ** 2) * 100 * 8)
+        assert self.test_shape.volume() == pytest.approx(math.pi * (10 ** 2) * 100 * 8)
 
     def test_start_angle(self):
         """Checks that the coolant channels are placed at the correct azimuthal placement
         angles for a given start angle."""
 
         assert self.test_shape.azimuth_placement_angle == [
-            0, 45, 90, 135, 180, 225, 270, 315
+            0,
+            45,
+            90,
+            135,
+            180,
+            225,
+            270,
+            315,
         ]
         self.test_shape.start_angle = 10
         assert self.test_shape.azimuth_placement_angle == [
-            10, 55, 100, 145, 190, 235, 280, 325
+            10,
+            55,
+            100,
+            145,
+            190,
+            235,
+            280,
+            325,
         ]
diff --git a/tests/test_parametric_components/test_cutting_wedge_fs.py b/tests/test_parametric_components/test_cutting_wedge_fs.py
index 2fc445ac9..0a03b403f 100644
--- a/tests/test_parametric_components/test_cutting_wedge_fs.py
+++ b/tests/test_parametric_components/test_cutting_wedge_fs.py
@@ -1,21 +1,19 @@
-
 import unittest
 
 import numpy as np
+
 import paramak
 
 
 class TestCuttingWedgeFS(unittest.TestCase):
-
     def test_shape_construction_and_volume(self):
         """Makes cutting cylinders from shapes and checks the
         volume of the cutter shape is larger than the shape it
         encompasses."""
 
-        hoop_shape = paramak.PoloidalFieldCoil(height=20,
-                                               width=20,
-                                               center_point=(50, 200),
-                                               rotation_angle=180)
+        hoop_shape = paramak.PoloidalFieldCoil(
+            height=20, width=20, center_point=(50, 200), rotation_angle=180
+        )
 
         cutter = paramak.CuttingWedgeFS(
             shape=hoop_shape,
@@ -29,9 +27,7 @@ def test_invalid_parameters_errors(self):
         shape parameters."""
 
         shape = paramak.ExtrudeStraightShape(
-            distance=1,
-            points=[(0, 0), (0, 1), (1, 1)],
-            rotation_angle=180
+            distance=1, points=[(0, 0), (0, 1), (1, 1)], rotation_angle=180
         )
 
         cutter = paramak.CuttingWedgeFS(
@@ -45,7 +41,7 @@ def incorrect_rotation_angle():
 
         def incorrect_shape_points():
             shape.rotation_angle = 180
-            cutter.shape.points = [(0, 0, 'straight')]
+            cutter.shape.points = [(0, 0, "straight")]
             cutter.solid
 
         def incorrect_shape_rotation_angle():
@@ -65,7 +61,7 @@ def test_different_workplanes(self):
             2,
             points=[(-0.5, -0.5), (0.5, -0.5), (0.5, 0.5), (-0.5, 0.5)],
             workplane="XY",
-            rotation_axis="Z"
+            rotation_axis="Z",
         )
         rectangle.rotation_angle = 360
         volume_full = rectangle.volume()
diff --git a/tests/test_parametric_components/test_divertor_iter.py b/tests/test_parametric_components/test_divertor_iter.py
index a67e6bc37..ad8ec9f3d 100644
--- a/tests/test_parametric_components/test_divertor_iter.py
+++ b/tests/test_parametric_components/test_divertor_iter.py
@@ -1,11 +1,9 @@
-
 import unittest
 
 import paramak
 
 
 class TestDivertorITER(unittest.TestCase):
-
     def test_creation(self):
         """Creates an ITER-type divertor using the ITERtypeDivertor parametric
         component and checks that a cadquery solid is created"""
diff --git a/tests/test_parametric_components/test_divertor_iter_no_dome.py b/tests/test_parametric_components/test_divertor_iter_no_dome.py
index 2996874fe..8b0e3cf2d 100644
--- a/tests/test_parametric_components/test_divertor_iter_no_dome.py
+++ b/tests/test_parametric_components/test_divertor_iter_no_dome.py
@@ -1,11 +1,9 @@
-
 import unittest
 
 import paramak
 
 
 class TestDivertorITERNoDome(unittest.TestCase):
-
     def test_creation(self):
         """Creates an ITER-type divertor using the ITERtypeDivertorNoDome
         parametric component and checks that a cadquery solid is created."""
diff --git a/tests/test_parametric_components/test_extrude_rectangle.py b/tests/test_parametric_components/test_extrude_rectangle.py
index c6126f273..7c2a9f102 100644
--- a/tests/test_parametric_components/test_extrude_rectangle.py
+++ b/tests/test_parametric_components/test_extrude_rectangle.py
@@ -1,12 +1,11 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestExtrudeRectangle(unittest.TestCase):
 
+class TestExtrudeRectangle(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.ExtrudeRectangle(
             height=50, width=60, center_point=(1000, 500), distance=333
@@ -23,11 +22,11 @@ def test_processed_points_calculation(self):
         ExtrudeRectangle are calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (1030.0, 525.0, 'straight'),
-            (1030.0, 475.0, 'straight'),
-            (970.0, 475.0, 'straight'),
-            (970.0, 525.0, 'straight'),
-            (1030.0, 525.0, 'straight')
+            (1030.0, 525.0, "straight"),
+            (1030.0, 475.0, "straight"),
+            (970.0, 475.0, "straight"),
+            (970.0, 525.0, "straight"),
+            (1030.0, 525.0, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -38,7 +37,7 @@ def test_points_calculation(self):
             (1030.0, 525.0),
             (1030.0, 475.0),
             (970.0, 475.0),
-            (970.0, 525.0)
+            (970.0, 525.0),
         ]
 
     def test_creation(self):
@@ -60,9 +59,6 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 6
         assert len(set([round(i) for i in self.test_shape.areas])) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * 50)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * 333)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * 333)) == 2
+        assert self.test_shape.areas.count(pytest.approx(60 * 50)) == 2
+        assert self.test_shape.areas.count(pytest.approx(50 * 333)) == 2
+        assert self.test_shape.areas.count(pytest.approx(60 * 333)) == 2
diff --git a/tests/test_parametric_components/test_hexagon_pin.py b/tests/test_parametric_components/test_hexagon_pin.py
index 878f708a9..49f564b28 100644
--- a/tests/test_parametric_components/test_hexagon_pin.py
+++ b/tests/test_parametric_components/test_hexagon_pin.py
@@ -1,22 +1,22 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestHexagonPin(unittest.TestCase):
 
+class TestHexagonPin(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.HexagonPin(
-            length_of_side=5, distance=42., center_point=(0, 0))
+            length_of_side=5, distance=42.0, center_point=(0, 0)
+        )
 
     def test_setting_parameters(self):
         """Checks that the default parameters and user parameters are set"""
 
         assert self.test_shape.length_of_side == 5
-        assert self.test_shape.distance == 42.
+        assert self.test_shape.distance == 42.0
         assert self.test_shape.center_point == (0, 0)
         assert self.test_shape.name == "hexagon_pin"
 
@@ -28,8 +28,10 @@ def test_volume(self):
 
         hexagon_face_area = (3 * math.sqrt(3) / 2) * math.pow(length, 2)
         # this needs a pytest.approx() as the volumes are not exact
-        assert pytest.approx(self.test_shape.volume(),
-                             rel=0.1) == hexagon_face_area * distance
+        assert (
+            pytest.approx(self.test_shape.volume(), rel=0.1)
+            == hexagon_face_area * distance
+        )
 
     def test_distance_impacts_volume(self):
         """Checks that changing the distance argument results in the
@@ -39,8 +41,7 @@ def test_distance_impacts_volume(self):
 
         self.test_shape.distance = self.test_shape.distance * 2
 
-        assert pytest.approx(test_shape_volume * 2,
-                             rel=0.1) == self.test_shape.volume()
+        assert pytest.approx(test_shape_volume * 2, rel=0.1) == self.test_shape.volume()
 
     def test_length_of_sides_impacts_volume(self):
         """Checks that changing the length_of_sides argument results in a the
@@ -50,8 +51,7 @@ def test_length_of_sides_impacts_volume(self):
 
         self.test_shape.length_of_side = self.test_shape.length_of_side * 2
 
-        assert pytest.approx(test_shape_volume * 4,
-                             rel=0.1) == self.test_shape.volume()
+        assert pytest.approx(test_shape_volume * 4, rel=0.1) == self.test_shape.volume()
 
     def test_areas_are_correct(self):
         """Tests the areas of the faces are the correct sizes"""
@@ -64,7 +64,5 @@ def test_areas_are_correct(self):
         hexagon_face_area = (3 * math.sqrt(3) / 2) * math.pow(length, 2)
 
         assert len(test_shape_areas) == 8
-        assert test_shape_areas.count(pytest.approx(hexagon_face_area,
-                                                    rel=0.1)) == 2
-        assert test_shape_areas.count(pytest.approx(length * distance,
-                                                    rel=0.1)) == 6
+        assert test_shape_areas.count(pytest.approx(hexagon_face_area, rel=0.1)) == 2
+        assert test_shape_areas.count(pytest.approx(length * distance, rel=0.1)) == 6
diff --git a/tests/test_parametric_components/test_inboard_firstwall_fccs.py b/tests/test_parametric_components/test_inboard_firstwall_fccs.py
index 786271a70..25cb47ee6 100644
--- a/tests/test_parametric_components/test_inboard_firstwall_fccs.py
+++ b/tests/test_parametric_components/test_inboard_firstwall_fccs.py
@@ -1,24 +1,21 @@
-
 import unittest
 
 import numpy as np
+
 import paramak
 
 
 class TestInboardFirstwallFCCS(unittest.TestCase):
-
     def test_construction_with_CenterColumnShieldCylinder(self):
         """Makes a firstwall from a CenterColumnShieldCylinder and checks
         the volume is smaller than the shield."""
 
         test_shape_1 = paramak.CenterColumnShieldCylinder(
-            height=100,
-            inner_radius=20,
-            outer_radius=80)
+            height=100, inner_radius=20, outer_radius=80
+        )
         test_shape_2 = paramak.InboardFirstwallFCCS(
-            central_column_shield=test_shape_1,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=test_shape_1, thickness=20, rotation_angle=180
+        )
         assert test_shape_1.solid is not None
         assert test_shape_2.solid is not None
         assert test_shape_1.volume() > test_shape_2.volume()
@@ -28,14 +25,11 @@ def test_construction_with_CenterColumnShieldHyperbola(self):
         the volume is smaller than the shield."""
 
         a = paramak.CenterColumnShieldHyperbola(
-            height=200,
-            inner_radius=20,
-            mid_radius=80,
-            outer_radius=120)
+            height=200, inner_radius=20, mid_radius=80, outer_radius=120
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
         assert a.solid is not None
         assert b.solid is not None
         assert a.volume() > b.volume()
@@ -45,15 +39,11 @@ def test_construction_with_CenterColumnShieldFlatTopHyperbola(self):
         checks the volume is smaller than the shield."""
 
         a = paramak.CenterColumnShieldFlatTopHyperbola(
-            height=200,
-            arc_height=100,
-            inner_radius=50,
-            mid_radius=80,
-            outer_radius=100)
+            height=200, arc_height=100, inner_radius=50, mid_radius=80, outer_radius=100
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
         assert a.solid is not None
         assert b.solid is not None
         assert a.volume() > b.volume()
@@ -63,14 +53,11 @@ def test_construction_with_CenterColumnShieldPlasmaHyperbola(self):
         checks the volume is smaller than the shield."""
 
         a = paramak.CenterColumnShieldPlasmaHyperbola(
-            height=601,
-            inner_radius=20,
-            mid_offset=50,
-            edge_offset=0)
+            height=601, inner_radius=20, mid_offset=50, edge_offset=0
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
         assert a.solid is not None
         assert b.solid is not None
         assert a.volume() > b.volume()
@@ -80,14 +67,11 @@ def test_construction_with_CenterColumnShieldCircular(self):
         the volume is smaller than the shield."""
 
         a = paramak.CenterColumnShieldCircular(
-            height=300,
-            inner_radius=20,
-            mid_radius=50,
-            outer_radius=100)
+            height=300, inner_radius=20, mid_radius=50, outer_radius=100
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
         assert a.solid is not None
         assert b.solid is not None
         assert a.volume() > b.volume()
@@ -97,15 +81,11 @@ def test_construction_with_CenterColumnShieldFlatTopCircular(self):
         checks the volume is smaller than the shield."""
 
         a = paramak.CenterColumnShieldFlatTopCircular(
-            height=500,
-            arc_height=300,
-            inner_radius=30,
-            mid_radius=70,
-            outer_radius=120)
+            height=500, arc_height=300, inner_radius=30, mid_radius=70, outer_radius=120
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
         assert a.solid is not None
         assert b.solid is not None
         assert a.volume() > b.volume()
@@ -116,37 +96,33 @@ def test_construction_with_string():
             should fail as it trys to use a string."""
 
             b = paramak.InboardFirstwallFCCS(
-                central_column_shield="incorrect type",
-                thickness=20,
-                rotation_angle=180)
+                central_column_shield="incorrect type", thickness=20, rotation_angle=180
+            )
             b.solid
 
-        self.assertRaises(
-            ValueError,
-            test_construction_with_string)
+        self.assertRaises(ValueError, test_construction_with_string)
 
     def test_boolean_union(self):
         """Makes two halves of a 360 firstwall and performs a union and checks
         that the volume corresponds to 2 times the volume of 1 half."""
 
         a = paramak.CenterColumnShieldFlatTopCircular(
-            height=500,
-            arc_height=300,
-            inner_radius=30,
-            mid_radius=70,
-            outer_radius=120)
+            height=500, arc_height=300, inner_radius=30, mid_radius=70, outer_radius=120
+        )
         b = paramak.InboardFirstwallFCCS(
             central_column_shield=a,
             thickness=20,
             rotation_angle=180,
-            azimuth_placement_angle=0)
+            azimuth_placement_angle=0,
+        )
 
         c = paramak.InboardFirstwallFCCS(
             central_column_shield=a,
             thickness=20,
             rotation_angle=180,
             azimuth_placement_angle=180,
-            union=b)
+            union=b,
+        )
         assert np.isclose(c.volume(), 2 * b.volume())
 
     def test_azimuth_placement_angle(self):
@@ -155,23 +131,22 @@ def test_azimuth_placement_angle(self):
         1 half."""
 
         a = paramak.CenterColumnShieldFlatTopCircular(
-            height=500,
-            arc_height=300,
-            inner_radius=30,
-            mid_radius=70,
-            outer_radius=120)
+            height=500, arc_height=300, inner_radius=30, mid_radius=70, outer_radius=120
+        )
         b = paramak.InboardFirstwallFCCS(
             central_column_shield=a,
             thickness=20,
             rotation_angle=180,
-            azimuth_placement_angle=0)
+            azimuth_placement_angle=0,
+        )
 
         c = paramak.InboardFirstwallFCCS(
             central_column_shield=a,
             thickness=20,
             rotation_angle=180,
             azimuth_placement_angle=90,
-            cut=b)
+            cut=b,
+        )
         assert np.isclose(c.volume(), 0.5 * b.volume())
 
     def test_cut_attribute(self):
@@ -179,13 +154,11 @@ def test_cut_attribute(self):
         the shape is not affected."""
 
         a = paramak.CenterColumnShieldCylinder(
-            height=100,
-            inner_radius=20,
-            outer_radius=80)
+            height=100, inner_radius=20, outer_radius=80
+        )
         b = paramak.InboardFirstwallFCCS(
-            central_column_shield=a,
-            thickness=20,
-            rotation_angle=180)
+            central_column_shield=a, thickness=20, rotation_angle=180
+        )
 
         volume_1 = b.volume()
         b.cut = None
diff --git a/tests/test_parametric_components/test_inner_tf_coils_circular.py b/tests/test_parametric_components/test_inner_tf_coils_circular.py
index 6ae8b94e8..70eea2ce1 100644
--- a/tests/test_parametric_components/test_inner_tf_coils_circular.py
+++ b/tests/test_parametric_components/test_inner_tf_coils_circular.py
@@ -1,18 +1,12 @@
-
 import unittest
 
 import paramak
 
 
 class TestInnerTfCoilsCircular(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.InnerTfCoilsCircular(
-            height=500,
-            inner_radius=50,
-            outer_radius=150,
-            number_of_coils=6,
-            gap_size=5
+            height=500, inner_radius=50, outer_radius=150, number_of_coils=6, gap_size=5
         )
 
     def test_default_parameters(self):
@@ -28,12 +22,12 @@ def test_points_calculation(self):
         component are calculated correctly from the parameters given."""
 
         assert self.test_shape.points == [
-            (49.937460888595446, 2.5, 'circle'),
-            (43.300748759659555, 25.000903120744287, 'circle'),
-            (27.1320420790315, 41.99824154201773, 'straight'),
-            (77.154447582418, 128.6358861991937, 'circle'),
-            (129.90375269002172, 75.00010024693078, 'circle'),
-            (149.97916521970643, 2.5, 'straight'),
+            (49.937460888595446, 2.5, "circle"),
+            (43.300748759659555, 25.000903120744287, "circle"),
+            (27.1320420790315, 41.99824154201773, "straight"),
+            (77.154447582418, 128.6358861991937, "circle"),
+            (129.90375269002172, 75.00010024693078, "circle"),
+            (149.97916521970643, 2.5, "straight"),
         ]
 
     def test_processed_points_calculation(self):
@@ -42,13 +36,13 @@ def test_processed_points_calculation(self):
         parameters given."""
 
         assert self.test_shape.processed_points == [
-            (49.937460888595446, 2.5, 'circle'),
-            (43.300748759659555, 25.000903120744287, 'circle'),
-            (27.1320420790315, 41.99824154201773, 'straight'),
-            (77.154447582418, 128.6358861991937, 'circle'),
-            (129.90375269002172, 75.00010024693078, 'circle'),
-            (149.97916521970643, 2.5, 'straight'),
-            (49.937460888595446, 2.5, 'circle')
+            (49.937460888595446, 2.5, "circle"),
+            (43.300748759659555, 25.000903120744287, "circle"),
+            (27.1320420790315, 41.99824154201773, "straight"),
+            (77.154447582418, 128.6358861991937, "circle"),
+            (129.90375269002172, 75.00010024693078, "circle"),
+            (149.97916521970643, 2.5, "straight"),
+            (49.937460888595446, 2.5, "circle"),
         ]
 
     def test_creation(self):
@@ -63,11 +57,9 @@ def test_azimuth_offset(self):
         component and checks that the azimuthal start angle can be changed
         correctly."""
 
-        assert self.test_shape.azimuth_placement_angle == [
-            0, 60, 120, 180, 240, 300]
+        assert self.test_shape.azimuth_placement_angle == [0, 60, 120, 180, 240, 300]
         self.test_shape.azimuth_start_angle = 20
-        assert self.test_shape.azimuth_placement_angle == [
-            20, 80, 140, 200, 260, 320]
+        assert self.test_shape.azimuth_placement_angle == [20, 80, 140, 200, 260, 320]
 
     def test_attributes(self):
         """Checks that changing the attributes of InnerTfCoilsCircular affects
@@ -94,7 +86,4 @@ def test_incorrect_gap_size():
             self.test_shape.gap_size = 50
             self.test_shape.solid
 
-        self.assertRaises(
-            ValueError,
-            test_incorrect_gap_size
-        )
+        self.assertRaises(ValueError, test_incorrect_gap_size)
diff --git a/tests/test_parametric_components/test_inner_tf_coils_flat.py b/tests/test_parametric_components/test_inner_tf_coils_flat.py
index 5291d6ef3..d514a2ffa 100644
--- a/tests/test_parametric_components/test_inner_tf_coils_flat.py
+++ b/tests/test_parametric_components/test_inner_tf_coils_flat.py
@@ -1,19 +1,14 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestInnerTfCoilsFlat(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.InnerTfCoilsFlat(
-            height=500,
-            inner_radius=50,
-            outer_radius=150,
-            number_of_coils=6,
-            gap_size=5
+            height=500, inner_radius=50, outer_radius=150, number_of_coils=6, gap_size=5
         )
 
         self.test_shape2 = paramak.InnerTfCoilsFlat(
@@ -22,7 +17,7 @@ def setUp(self):
             outer_radius=150,
             number_of_coils=6,
             gap_size=5,
-            radius_type='straight'
+            radius_type="straight",
         )
 
         # hexagon with 0 inner radius
@@ -32,7 +27,7 @@ def setUp(self):
             outer_radius=20,
             number_of_coils=6,
             gap_size=0,
-            radius_type='straight',
+            radius_type="straight",
         )
 
     def test_default_parameters(self):
@@ -52,7 +47,7 @@ def test_points_calculation(self):
             (49.937460888595446, 2.5),
             (27.1320420790315, 41.99824154201773),
             (77.154447582418, 128.6358861991937),
-            (149.97916521970643, 2.5)
+            (149.97916521970643, 2.5),
         ]
 
     def test_processed_points_calculation(self):
@@ -60,11 +55,11 @@ def test_processed_points_calculation(self):
         component are calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (49.937460888595446, 2.5, 'straight'),
-            (27.1320420790315, 41.99824154201773, 'straight'),
-            (77.154447582418, 128.6358861991937, 'straight'),
-            (149.97916521970643, 2.5, 'straight'),
-            (49.937460888595446, 2.5, 'straight')
+            (49.937460888595446, 2.5, "straight"),
+            (27.1320420790315, 41.99824154201773, "straight"),
+            (77.154447582418, 128.6358861991937, "straight"),
+            (149.97916521970643, 2.5, "straight"),
+            (49.937460888595446, 2.5, "straight"),
         ]
 
     def test_creation(self):
@@ -79,11 +74,9 @@ def test_azimuth_offset(self):
         component and checks that the azimuthal start angle can be changed
         correctly."""
 
-        assert self.test_shape.azimuth_placement_angle == [
-            0, 60, 120, 180, 240, 300]
+        assert self.test_shape.azimuth_placement_angle == [0, 60, 120, 180, 240, 300]
         self.test_shape.azimuth_start_angle = 20
-        assert self.test_shape.azimuth_placement_angle == [
-            20, 80, 140, 200, 260, 320]
+        assert self.test_shape.azimuth_placement_angle == [20, 80, 140, 200, 260, 320]
 
     def test_attributes(self):
         """Checks that changing the attributes of InnerTfCoilsFlat affects the
@@ -110,22 +103,16 @@ def test_incorrect_gap_size():
             self.test_shape.gap_size = 50
             self.test_shape.solid
 
-        self.assertRaises(
-            ValueError,
-            test_incorrect_gap_size
-        )
+        self.assertRaises(ValueError, test_incorrect_gap_size)
 
     def test_radius_type(self):
         """Checks that a ValueError is raised when radius_type is not a
         valid option."""
 
         def test_incorrect_radius_type():
-            self.test_shape.radius_type = 'coucou'
+            self.test_shape.radius_type = "coucou"
 
-        self.assertRaises(
-            ValueError,
-            test_incorrect_radius_type
-        )
+        self.assertRaises(ValueError, test_incorrect_radius_type)
 
     def test_volume_changes_with_radius_type(self):
         """Checks the analytical volume of the hex shaped extrusion and
@@ -143,13 +130,13 @@ def test_volume_changes_with_radius_type_for_corners(self):
         that adding a hole reduces voulume when the radius is to the corners."""
 
         hex_shape = self.test_shape_3
-        hex_shape.radius_type = 'corner'
+        hex_shape.radius_type = "corner"
         hex_volume = hex_shape.volume()
 
         assert pytest.approx(hex_volume, abs=0.5) == 1039.2 * 10
 
         hex_with_hole = self.test_shape_3
-        hex_with_hole.radius_type = 'corner'
+        hex_with_hole.radius_type = "corner"
         hex_with_hole.inner_radius = 2
 
         assert hex_volume > hex_with_hole.volume()
diff --git a/tests/test_parametric_components/test_plasma.py b/tests/test_parametric_components/test_plasma.py
index 72d8bb908..347e1b667 100644
--- a/tests/test_parametric_components/test_plasma.py
+++ b/tests/test_parametric_components/test_plasma.py
@@ -1,9 +1,9 @@
-
 import os
 import unittest
-import pytest
 from pathlib import Path
 
+import pytest
+
 import paramak
 
 
@@ -49,24 +49,24 @@ def major_radius_out_of_range():
     def test_plasma_points_of_interest(self):
         test_plasma = paramak.Plasma(vertical_displacement=2)
         assert test_plasma.high_point == (
-            test_plasma.major_radius -
-            test_plasma.triangularity * test_plasma.minor_radius,
-            test_plasma.elongation * test_plasma.minor_radius +
-            test_plasma.vertical_displacement,
+            test_plasma.major_radius
+            - test_plasma.triangularity * test_plasma.minor_radius,
+            test_plasma.elongation * test_plasma.minor_radius
+            + test_plasma.vertical_displacement,
         )
         assert test_plasma.low_point == (
-            test_plasma.major_radius -
-            test_plasma.triangularity * test_plasma.minor_radius,
-            -test_plasma.elongation * test_plasma.minor_radius +
-            test_plasma.vertical_displacement,
+            test_plasma.major_radius
+            - test_plasma.triangularity * test_plasma.minor_radius,
+            -test_plasma.elongation * test_plasma.minor_radius
+            + test_plasma.vertical_displacement,
         )
         assert test_plasma.outer_equatorial_point == (
             test_plasma.major_radius + test_plasma.minor_radius,
-            test_plasma.vertical_displacement
+            test_plasma.vertical_displacement,
         )
         assert test_plasma.inner_equatorial_point == (
             test_plasma.major_radius - test_plasma.minor_radius,
-            test_plasma.vertical_displacement
+            test_plasma.vertical_displacement,
         )
 
     def test_plasma_x_points(self):
@@ -103,25 +103,20 @@ def test_plasma_x_points(self):
                 # Expected
                 expected_lower_x_point, expected_upper_x_point = None, None
                 if config == "single-null" or config == "double-null":
-                    expected_lower_x_point = (1 -
-                                              (1 +
-                                               test_plasma.x_point_shift) *
-                                              triangularity *
-                                              minor_radius, -
-                                              (1 +
-                                               test_plasma.x_point_shift) *
-                                              elongation *
-                                              minor_radius +
-                                              vertical_displacement, )
+                    expected_lower_x_point = (
+                        1
+                        - (1 + test_plasma.x_point_shift)
+                        * triangularity
+                        * minor_radius,
+                        -(1 + test_plasma.x_point_shift) * elongation * minor_radius
+                        + vertical_displacement,
+                    )
 
                     if config == "double-null":
                         expected_upper_x_point = (
                             expected_lower_x_point[0],
-                            (1 +
-                             test_plasma.x_point_shift) *
-                            elongation *
-                            minor_radius +
-                            vertical_displacement,
+                            (1 + test_plasma.x_point_shift) * elongation * minor_radius
+                            + vertical_displacement,
                         )
 
                 # Check
@@ -159,15 +154,13 @@ def test_plasma_x_points_plasmaboundaries(self):
                 # Expected
                 expected_lower_x_point, expected_upper_x_point = None, None
                 if config == "single-null" or config == "double-null":
-                    expected_lower_x_point = (1 -
-                                              (1 +
-                                               test_plasma.x_point_shift) *
-                                              triangularity *
-                                              minor_radius, -
-                                              (1 +
-                                               test_plasma.x_point_shift) *
-                                              elongation *
-                                              minor_radius, )
+                    expected_lower_x_point = (
+                        1
+                        - (1 + test_plasma.x_point_shift)
+                        * triangularity
+                        * minor_radius,
+                        -(1 + test_plasma.x_point_shift) * elongation * minor_radius,
+                    )
 
                     if config == "double-null":
                         expected_upper_x_point = (
@@ -220,7 +213,9 @@ def test_export_plasma_from_points_export(self):
         test_plasma.export_stp("plasma.stp")
         assert test_plasma.high_point[0] > test_plasma.inner_equatorial_x_point
         assert test_plasma.high_point[0] < test_plasma.outer_equatorial_x_point
-        assert test_plasma.outer_equatorial_x_point > test_plasma.inner_equatorial_x_point
+        assert (
+            test_plasma.outer_equatorial_x_point > test_plasma.inner_equatorial_x_point
+        )
         assert Path("plasma.stp").exists()
         os.system("rm plasma.stp")
 
diff --git a/tests/test_parametric_components/test_poloidal_field_coil.py b/tests/test_parametric_components/test_poloidal_field_coil.py
index ec4f85071..366baa03f 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil.py
@@ -1,13 +1,12 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestPoloidalFieldCoil(unittest.TestCase):
 
+class TestPoloidalFieldCoil(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.PoloidalFieldCoil(
             height=50, width=60, center_point=(1000, 500)
@@ -34,11 +33,11 @@ def test_processed_points_calculation(self):
         calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (1030.0, 525.0, 'straight'),
-            (1030.0, 475.0, 'straight'),
-            (970.0, 475.0, 'straight'),
-            (970.0, 525.0, 'straight'),
-            (1030.0, 525.0, 'straight')
+            (1030.0, 525.0, "straight"),
+            (1030.0, 475.0, "straight"),
+            (970.0, 475.0, "straight"),
+            (970.0, 525.0, "straight"),
+            (1030.0, 525.0, "straight"),
         ]
 
     def test_creation(self):
@@ -52,8 +51,7 @@ def test_absolute_volume(self):
         """Creates a pf coil using the PoloidalFieldCoil parametric component
         and checks that the volume is correct"""
 
-        assert self.test_shape.volume() == pytest.approx(
-            50 * 60 * math.pi * 2 * 1000)
+        assert self.test_shape.volume() == pytest.approx(50 * 60 * math.pi * 2 * 1000)
 
     def test_absolute_areas(self):
         """Creates a pf coil using the PoloidalFieldCoil parametric component
@@ -61,9 +59,6 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 4
         assert len(set([round(i) for i in self.test_shape.areas])) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 1000)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 970)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 1030)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_case.py b/tests/test_parametric_components/test_poloidal_field_coil_case.py
index bc2bc6ee5..0e30377e9 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_case.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_case.py
@@ -1,19 +1,15 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestPoloidalFieldCoilCase(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.PoloidalFieldCoilCase(
-            casing_thickness=5,
-            coil_height=50,
-            coil_width=50,
-            center_point=(1000, 500)
+            casing_thickness=5, coil_height=50, coil_width=50, center_point=(1000, 500)
         )
 
     def test_default_parameters(self):
@@ -27,17 +23,17 @@ def test_processed_points_calculation(self):
         given."""
 
         assert self.test_shape.processed_points == [
-            (1025.0, 525.0, 'straight'),
-            (1025.0, 475.0, 'straight'),
-            (975.0, 475.0, 'straight'),
-            (975.0, 525.0, 'straight'),
-            (1025.0, 525.0, 'straight'),
-            (1030.0, 530.0, 'straight'),
-            (1030.0, 470.0, 'straight'),
-            (970.0, 470.0, 'straight'),
-            (970.0, 530.0, 'straight'),
-            (1030.0, 530.0, 'straight'),
-            (1025.0, 525.0, 'straight')
+            (1025.0, 525.0, "straight"),
+            (1025.0, 475.0, "straight"),
+            (975.0, 475.0, "straight"),
+            (975.0, 525.0, "straight"),
+            (1025.0, 525.0, "straight"),
+            (1030.0, 530.0, "straight"),
+            (1030.0, 470.0, "straight"),
+            (970.0, 470.0, "straight"),
+            (970.0, 530.0, "straight"),
+            (1030.0, 530.0, "straight"),
+            (1025.0, 525.0, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -69,7 +65,8 @@ def test_absolute_volume(self):
         component and checks that its volume is correct."""
 
         assert self.test_shape.volume() == pytest.approx(
-            (math.pi * 2 * 1000) * ((60 * 5 * 2) + (50 * 5 * 2)))
+            (math.pi * 2 * 1000) * ((60 * 5 * 2) + (50 * 5 * 2))
+        )
 
     def test_absolute_areas(self):
         """Creates a pf coil case using the PoloidalFieldCoilCase parametric
@@ -77,15 +74,9 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 8
         assert len(set([round(i) for i in self.test_shape.areas])) == 6
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 1000)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 1000)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 1025)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 975)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 1030)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 970)) == 1
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1000)) == 2
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1025)) == 1
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 975)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1030)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 970)) == 1
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_case_fc.py b/tests/test_parametric_components/test_poloidal_field_coil_case_fc.py
index 5d196687b..68a5ce4dc 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_case_fc.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_case_fc.py
@@ -1,13 +1,12 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestPoloidalFieldCoilCaseFC(unittest.TestCase):
-
     def setUp(self):
         self.pf_coil = paramak.PoloidalFieldCoil(
             height=50, width=60, center_point=(1000, 500)
@@ -34,7 +33,8 @@ def test_absolute_volume(self):
         component and checks that its volume is correct."""
 
         assert self.test_shape.volume() == pytest.approx(
-            (math.pi * 2 * 1000) * ((50 * 5 * 2) + (70 * 5 * 2)))
+            (math.pi * 2 * 1000) * ((50 * 5 * 2) + (70 * 5 * 2))
+        )
 
     def test_absolute_areas(self):
         """Creates a pf coil case using the PoloidalFieldCoilCaseFC parametric
@@ -42,15 +42,9 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 8
         assert len(set([round(i) for i in self.test_shape.areas])) == 6
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 1000)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(70 * math.pi * 2 * 1000)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 1030)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(50 * math.pi * 2 * 970)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 1035)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(60 * math.pi * 2 * 965)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2
+        assert self.test_shape.areas.count(pytest.approx(70 * math.pi * 2 * 1000)) == 2
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1
+        assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1035)) == 1
+        assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 965)) == 1
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_case_set.py b/tests/test_parametric_components/test_poloidal_field_coil_case_set.py
index e5f0bc63e..27f70decb 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_case_set.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_case_set.py
@@ -1,13 +1,12 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestPoloidalFieldCoilCaseSet(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.PoloidalFieldCoilCaseSet(
             heights=[10, 10, 20, 20],
@@ -26,47 +25,47 @@ def test_processed_points_calculation(self):
         calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (105.0, 105.0, 'straight'),
-            (105.0, 95.0, 'straight'),
-            (95.0, 95.0, 'straight'),
-            (95.0, 105.0, 'straight'),
-            (105.0, 105.0, 'straight'),
-            (110.0, 110.0, 'straight'),
-            (110.0, 90.0, 'straight'),
-            (90.0, 90.0, 'straight'),
-            (90.0, 110.0, 'straight'),
-            (110.0, 110.0, 'straight'),
-            (105.0, 155.0, 'straight'),
-            (105.0, 145.0, 'straight'),
-            (95.0, 145.0, 'straight'),
-            (95.0, 155.0, 'straight'),
-            (105.0, 155.0, 'straight'),
-            (115.0, 165.0, 'straight'),
-            (115.0, 135.0, 'straight'),
-            (85.0, 135.0, 'straight'),
-            (85.0, 165.0, 'straight'),
-            (115.0, 165.0, 'straight'),
-            (60.0, 210.0, 'straight'),
-            (60.0, 190.0, 'straight'),
-            (40.0, 190.0, 'straight'),
-            (40.0, 210.0, 'straight'),
-            (60.0, 210.0, 'straight'),
-            (65.0, 215.0, 'straight'),
-            (65.0, 185.0, 'straight'),
-            (35.0, 185.0, 'straight'),
-            (35.0, 215.0, 'straight'),
-            (65.0, 215.0, 'straight'),
-            (70.0, 60.0, 'straight'),
-            (70.0, 40.0, 'straight'),
-            (30.0, 40.0, 'straight'),
-            (30.0, 60.0, 'straight'),
-            (70.0, 60.0, 'straight'),
-            (80.0, 70.0, 'straight'),
-            (80.0, 30.0, 'straight'),
-            (20.0, 30.0, 'straight'),
-            (20.0, 70.0, 'straight'),
-            (80.0, 70.0, 'straight'),
-            (105.0, 105.0, 'straight')
+            (105.0, 105.0, "straight"),
+            (105.0, 95.0, "straight"),
+            (95.0, 95.0, "straight"),
+            (95.0, 105.0, "straight"),
+            (105.0, 105.0, "straight"),
+            (110.0, 110.0, "straight"),
+            (110.0, 90.0, "straight"),
+            (90.0, 90.0, "straight"),
+            (90.0, 110.0, "straight"),
+            (110.0, 110.0, "straight"),
+            (105.0, 155.0, "straight"),
+            (105.0, 145.0, "straight"),
+            (95.0, 145.0, "straight"),
+            (95.0, 155.0, "straight"),
+            (105.0, 155.0, "straight"),
+            (115.0, 165.0, "straight"),
+            (115.0, 135.0, "straight"),
+            (85.0, 135.0, "straight"),
+            (85.0, 165.0, "straight"),
+            (115.0, 165.0, "straight"),
+            (60.0, 210.0, "straight"),
+            (60.0, 190.0, "straight"),
+            (40.0, 190.0, "straight"),
+            (40.0, 210.0, "straight"),
+            (60.0, 210.0, "straight"),
+            (65.0, 215.0, "straight"),
+            (65.0, 185.0, "straight"),
+            (35.0, 185.0, "straight"),
+            (35.0, 215.0, "straight"),
+            (65.0, 215.0, "straight"),
+            (70.0, 60.0, "straight"),
+            (70.0, 40.0, "straight"),
+            (30.0, 40.0, "straight"),
+            (30.0, 60.0, "straight"),
+            (70.0, 60.0, "straight"),
+            (80.0, 70.0, "straight"),
+            (80.0, 30.0, "straight"),
+            (20.0, 30.0, "straight"),
+            (20.0, 70.0, "straight"),
+            (80.0, 70.0, "straight"),
+            (105.0, 105.0, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -139,11 +138,12 @@ def test_absolute_volume(self):
         """Creates a set of pf coils using the PoloidalFieldCoilCaseSet
         parametric component and checks that the volume is correct."""
 
-        assert self.test_shape.volume() == pytest.approx((((20 * 5 * 2) +
-                                                           (10 * 5 * 2)) * math.pi * 2 * 100) + (((30 * 10 * 2) +
-                                                                                                  (10 * 10 * 2)) * math.pi * 2 * 100) + (((30 * 5 * 2) +
-                                                                                                                                          (20 * 5 * 2)) * math.pi * 2 * 50) + (((60 * 10 * 2) +
-                                                                                                                                                                                (20 * 10 * 2)) * math.pi * 2 * 50))
+        assert self.test_shape.volume() == pytest.approx(
+            (((20 * 5 * 2) + (10 * 5 * 2)) * math.pi * 2 * 100)
+            + (((30 * 10 * 2) + (10 * 10 * 2)) * math.pi * 2 * 100)
+            + (((30 * 5 * 2) + (20 * 5 * 2)) * math.pi * 2 * 50)
+            + (((60 * 10 * 2) + (20 * 10 * 2)) * math.pi * 2 * 50)
+        )
 
     def test_absolute_areas(self):
         """Creates a set of pf coils using the PoloidalFieldCoilCaseSet
@@ -151,38 +151,22 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 32
         assert len(set([round(i) for i in self.test_shape.areas])) == 16
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 100)) == 6
-        assert self.test_shape.areas.count(
-            pytest.approx(40 * math.pi * 2 * 50)) == 4
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 100)) == 4
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 50)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 105)) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 95)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 110)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 90)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 115)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 85)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 60)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 40)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 65)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 70)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 30)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(40 * math.pi * 2 * 80)) == 1
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 100)) == 6
+        assert self.test_shape.areas.count(pytest.approx(40 * math.pi * 2 * 50)) == 4
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 100)) == 4
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 50)) == 2
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 105)) == 3
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 95)) == 2
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 110)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 90)) == 1
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 115)) == 1
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 85)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 60)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 40)) == 2
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 65)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 70)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 30)) == 1
+        assert self.test_shape.areas.count(pytest.approx(40 * math.pi * 2 * 80)) == 1
 
     def test_PoloidalFieldCoilCaseSet_incorrect_thicknesses_1(self):
         """Checks that an error is raised when a PoloidalFieldCoilCaseSet is made
@@ -193,8 +177,7 @@ def make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_1():
             self.test_shape.solid
 
         self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_1
+            ValueError, make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_1
         )
 
     def test_PoloidalFieldCoil_incorrect_thicknesses_2(self):
@@ -202,11 +185,10 @@ def test_PoloidalFieldCoil_incorrect_thicknesses_2(self):
         with invalid casing thicknesses."""
 
         def make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_2():
-            self.test_shape.casing_thicknesses = [5, 5, 5, 'ten']
+            self.test_shape.casing_thicknesses = [5, 5, 5, "ten"]
 
         self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_2
+            ValueError, make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_2
         )
 
     def test_PoloidalFieldCoil_incorrect_thicknesses_3(self):
@@ -217,6 +199,5 @@ def make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_3():
             self.test_shape.casing_thicknesses = "ten"
 
         self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_3
+            ValueError, make_PoloidalFieldCoilCaseSet_incorrect_thicknesses_3
         )
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_case_set_fc.py b/tests/test_parametric_components/test_poloidal_field_coil_case_set_fc.py
index a580f6025..fde257fef 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_case_set_fc.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_case_set_fc.py
@@ -1,13 +1,12 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestPoloidalFieldCoilCaseSetFC(unittest.TestCase):
 
+class TestPoloidalFieldCoilCaseSetFC(unittest.TestCase):
     def setUp(self):
         self.pf_coils_set = paramak.PoloidalFieldCoilSet(
             heights=[10, 10, 20, 20],
@@ -30,47 +29,47 @@ def test_processed_points_calculation(self):
         PoloidalFieldCoilCaseSetFC are calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (105.0, 105.0, 'straight'),
-            (105.0, 95.0, 'straight'),
-            (95.0, 95.0, 'straight'),
-            (95.0, 105.0, 'straight'),
-            (105.0, 105.0, 'straight'),
-            (110.0, 110.0, 'straight'),
-            (110.0, 90.0, 'straight'),
-            (90.0, 90.0, 'straight'),
-            (90.0, 110.0, 'straight'),
-            (110.0, 110.0, 'straight'),
-            (105.0, 155.0, 'straight'),
-            (105.0, 145.0, 'straight'),
-            (95.0, 145.0, 'straight'),
-            (95.0, 155.0, 'straight'),
-            (105.0, 155.0, 'straight'),
-            (115.0, 165.0, 'straight'),
-            (115.0, 135.0, 'straight'),
-            (85.0, 135.0, 'straight'),
-            (85.0, 165.0, 'straight'),
-            (115.0, 165.0, 'straight'),
-            (60.0, 210.0, 'straight'),
-            (60.0, 190.0, 'straight'),
-            (40.0, 190.0, 'straight'),
-            (40.0, 210.0, 'straight'),
-            (60.0, 210.0, 'straight'),
-            (65.0, 215.0, 'straight'),
-            (65.0, 185.0, 'straight'),
-            (35.0, 185.0, 'straight'),
-            (35.0, 215.0, 'straight'),
-            (65.0, 215.0, 'straight'),
-            (70.0, 60.0, 'straight'),
-            (70.0, 40.0, 'straight'),
-            (30.0, 40.0, 'straight'),
-            (30.0, 60.0, 'straight'),
-            (70.0, 60.0, 'straight'),
-            (80.0, 70.0, 'straight'),
-            (80.0, 30.0, 'straight'),
-            (20.0, 30.0, 'straight'),
-            (20.0, 70.0, 'straight'),
-            (80.0, 70.0, 'straight'),
-            (105.0, 105.0, 'straight')
+            (105.0, 105.0, "straight"),
+            (105.0, 95.0, "straight"),
+            (95.0, 95.0, "straight"),
+            (95.0, 105.0, "straight"),
+            (105.0, 105.0, "straight"),
+            (110.0, 110.0, "straight"),
+            (110.0, 90.0, "straight"),
+            (90.0, 90.0, "straight"),
+            (90.0, 110.0, "straight"),
+            (110.0, 110.0, "straight"),
+            (105.0, 155.0, "straight"),
+            (105.0, 145.0, "straight"),
+            (95.0, 145.0, "straight"),
+            (95.0, 155.0, "straight"),
+            (105.0, 155.0, "straight"),
+            (115.0, 165.0, "straight"),
+            (115.0, 135.0, "straight"),
+            (85.0, 135.0, "straight"),
+            (85.0, 165.0, "straight"),
+            (115.0, 165.0, "straight"),
+            (60.0, 210.0, "straight"),
+            (60.0, 190.0, "straight"),
+            (40.0, 190.0, "straight"),
+            (40.0, 210.0, "straight"),
+            (60.0, 210.0, "straight"),
+            (65.0, 215.0, "straight"),
+            (65.0, 185.0, "straight"),
+            (35.0, 185.0, "straight"),
+            (35.0, 215.0, "straight"),
+            (65.0, 215.0, "straight"),
+            (70.0, 60.0, "straight"),
+            (70.0, 40.0, "straight"),
+            (30.0, 40.0, "straight"),
+            (30.0, 60.0, "straight"),
+            (70.0, 60.0, "straight"),
+            (80.0, 70.0, "straight"),
+            (80.0, 30.0, "straight"),
+            (20.0, 30.0, "straight"),
+            (20.0, 70.0, "straight"),
+            (80.0, 70.0, "straight"),
+            (105.0, 105.0, "straight"),
         ]
 
     def test_points_calculation(self):
@@ -142,8 +141,12 @@ def test_from_pf_coil_set_absolute_volume(self):
         """Creates a set of pf coil cases from a pf coil set object and checks
         that the volume is correct."""
 
-        assert self.test_shape.volume() == pytest.approx((((20 * 5 * 2) + (10 * 5 * 2)) * math.pi * 2 * 100) + (((30 * 10 * 2) + (
-            10 * 10 * 2)) * math.pi * 2 * 100) + (((30 * 5 * 2) + (20 * 5 * 2)) * math.pi * 2 * 50) + (((60 * 10 * 2) + (20 * 10 * 2)) * math.pi * 2 * 50))
+        assert self.test_shape.volume() == pytest.approx(
+            (((20 * 5 * 2) + (10 * 5 * 2)) * math.pi * 2 * 100)
+            + (((30 * 10 * 2) + (10 * 10 * 2)) * math.pi * 2 * 100)
+            + (((30 * 5 * 2) + (20 * 5 * 2)) * math.pi * 2 * 50)
+            + (((60 * 10 * 2) + (20 * 10 * 2)) * math.pi * 2 * 50)
+        )
 
     def test_from_pf_coil_set_absolute_areas(self):
         """Creates a set of pf coil cases from a pf coil set object and checks
@@ -151,38 +154,22 @@ def test_from_pf_coil_set_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 32
         assert len(set([round(i) for i in self.test_shape.areas])) == 16
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 100)) == 6
-        assert self.test_shape.areas.count(
-            pytest.approx(40 * math.pi * 2 * 50)) == 4
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 100)) == 4
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 50)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 105)) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * 2 * 95)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 110)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 90)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 115)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 85)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 60)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 40)) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * 2 * 65)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 70)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * 2 * 30)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(40 * math.pi * 2 * 80)) == 1
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 100)) == 6
+        assert self.test_shape.areas.count(pytest.approx(40 * math.pi * 2 * 50)) == 4
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 100)) == 4
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 50)) == 2
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 105)) == 3
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * 2 * 95)) == 2
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 110)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 90)) == 1
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 115)) == 1
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 85)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 60)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 40)) == 2
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * 2 * 65)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 70)) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * 2 * 30)) == 1
+        assert self.test_shape.areas.count(pytest.approx(40 * math.pi * 2 * 80)) == 1
 
     def test_PoloidalFieldCoilCaseSetFC_incorrect_lengths_FC(self):
         """Checks that an error is raised when a PoloidalFieldCoilCaseSetFC is made
@@ -193,8 +180,7 @@ def make_PoloidalFieldCoilCaseSetFC_incorrect_lengths_FC():
             self.test_shape.solid
 
         self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSetFC_incorrect_lengths_FC
+            ValueError, make_PoloidalFieldCoilCaseSetFC_incorrect_lengths_FC
         )
 
     def test_PoloidalFieldCoilCaseSetFC_incorrect_lengths(self):
@@ -209,10 +195,7 @@ def make_PoloidalFieldCoilCaseSetFC_incorrect_lengths():
             self.test_shape.pf_coils = [self.pf_coils_set]
             self.test_shape.solid
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSetFC_incorrect_lengths
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilCaseSetFC_incorrect_lengths)
 
     def test_PoloidalFieldCoilCaseSetFC_incorrect_pf_coil(self):
         """Checks that an error is raised when a PoloidalFieldCoilCaseSetFC is made
@@ -222,34 +205,31 @@ def make_PoloidalFieldCoilCaseSetFC_incorrect_pf_coil():
             self.test_shape.pf_coils = 20
             self.test_shape.solid
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilCaseSetFC_incorrect_pf_coil
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilCaseSetFC_incorrect_pf_coil)
 
     def test_from_list(self):
         """Creates a set of PF coil cases from a list of PF coils with a list
         of thicknesses."""
 
-        pf_coils_1 = paramak.PoloidalFieldCoil(height=10,
-                                               width=10,
-                                               center_point=(100, 100))
+        pf_coils_1 = paramak.PoloidalFieldCoil(
+            height=10, width=10, center_point=(100, 100)
+        )
 
-        pf_coils_2 = paramak.PoloidalFieldCoil(height=10,
-                                               width=10,
-                                               center_point=(100, 150))
+        pf_coils_2 = paramak.PoloidalFieldCoil(
+            height=10, width=10, center_point=(100, 150)
+        )
 
-        pf_coils_3 = paramak.PoloidalFieldCoil(height=20,
-                                               width=20,
-                                               center_point=(50, 200))
+        pf_coils_3 = paramak.PoloidalFieldCoil(
+            height=20, width=20, center_point=(50, 200)
+        )
 
-        pf_coils_4 = paramak.PoloidalFieldCoil(height=20,
-                                               width=40,
-                                               center_point=(50, 50))
+        pf_coils_4 = paramak.PoloidalFieldCoil(
+            height=20, width=40, center_point=(50, 50)
+        )
 
         test_shape = paramak.PoloidalFieldCoilCaseSetFC(
             pf_coils=[pf_coils_1, pf_coils_2, pf_coils_3, pf_coils_4],
-            casing_thicknesses=[5, 5, 10, 10]
+            casing_thicknesses=[5, 5, 10, 10],
         )
 
         assert test_shape.solid is not None
@@ -259,21 +239,21 @@ def test_PoloidalFieldCoilCaseSetFC_with_number_thickness(self):
         """Creates a set of PF coil cases from a list of PF coils with a
         single numerical thicknesses."""
 
-        pf_coils_1 = paramak.PoloidalFieldCoil(height=10,
-                                               width=10,
-                                               center_point=(100, 100))
+        pf_coils_1 = paramak.PoloidalFieldCoil(
+            height=10, width=10, center_point=(100, 100)
+        )
 
-        pf_coils_2 = paramak.PoloidalFieldCoil(height=10,
-                                               width=10,
-                                               center_point=(100, 150))
+        pf_coils_2 = paramak.PoloidalFieldCoil(
+            height=10, width=10, center_point=(100, 150)
+        )
 
-        pf_coils_3 = paramak.PoloidalFieldCoil(height=20,
-                                               width=20,
-                                               center_point=(50, 200))
+        pf_coils_3 = paramak.PoloidalFieldCoil(
+            height=20, width=20, center_point=(50, 200)
+        )
 
-        pf_coils_4 = paramak.PoloidalFieldCoil(height=20,
-                                               width=40,
-                                               center_point=(50, 50))
+        pf_coils_4 = paramak.PoloidalFieldCoil(
+            height=20, width=40, center_point=(50, 50)
+        )
 
         test_shape = paramak.PoloidalFieldCoilCaseSetFC(
             pf_coils=[pf_coils_1, pf_coils_2, pf_coils_3, pf_coils_4],
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_fp.py b/tests/test_parametric_components/test_poloidal_field_coil_fp.py
index e7b3ccbb8..2045e8a13 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_fp.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_fp.py
@@ -1,17 +1,15 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestPoloidalFieldCoilFP(unittest.TestCase):
 
+class TestPoloidalFieldCoilFP(unittest.TestCase):
     def test_shape_construction_and_volume(self):
         """Cuts a vessel cylinder with several different size port cutters."""
 
-        test_component = paramak.PoloidalFieldCoilFP(
-            corner_points=[(10, 10), (20, 22)])
+        test_component = paramak.PoloidalFieldCoilFP(corner_points=[(10, 10), (20, 22)])
 
         assert test_component.volume() == pytest.approx(12063.715789784808)
         assert test_component.corner_points == [(10, 10), (20, 22)]
diff --git a/tests/test_parametric_components/test_poloidal_field_coil_set.py b/tests/test_parametric_components/test_poloidal_field_coil_set.py
index 39b2e753f..3277eb31d 100644
--- a/tests/test_parametric_components/test_poloidal_field_coil_set.py
+++ b/tests/test_parametric_components/test_poloidal_field_coil_set.py
@@ -1,18 +1,17 @@
-
 import math
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestPoloidalFieldCoilSet(unittest.TestCase):
 
+class TestPoloidalFieldCoilSet(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.PoloidalFieldCoilSet(
             heights=[10, 15, 5],
             widths=[20, 25, 30],
-            center_points=[(100, 100), (200, 200), (300, 300)]
+            center_points=[(100, 100), (200, 200), (300, 300)],
         )
 
     def test_default_parameters(self):
@@ -45,19 +44,19 @@ def test_processed_points_calculation(self):
         given."""
 
         assert self.test_shape.processed_points == [
-            (110.0, 105.0, 'straight'),
-            (110.0, 95.0, 'straight'),
-            (90.0, 95.0, 'straight'),
-            (90.0, 105.0, 'straight'),
-            (212.5, 207.5, 'straight'),
-            (212.5, 192.5, 'straight'),
-            (187.5, 192.5, 'straight'),
-            (187.5, 207.5, 'straight'),
-            (315.0, 302.5, 'straight'),
-            (315.0, 297.5, 'straight'),
-            (285.0, 297.5, 'straight'),
-            (285.0, 302.5, 'straight'),
-            (110.0, 105.0, 'straight')
+            (110.0, 105.0, "straight"),
+            (110.0, 95.0, "straight"),
+            (90.0, 95.0, "straight"),
+            (90.0, 105.0, "straight"),
+            (212.5, 207.5, "straight"),
+            (212.5, 192.5, "straight"),
+            (187.5, 192.5, "straight"),
+            (187.5, 207.5, "straight"),
+            (315.0, 302.5, "straight"),
+            (315.0, 297.5, "straight"),
+            (285.0, 297.5, "straight"),
+            (285.0, 302.5, "straight"),
+            (110.0, 105.0, "straight"),
         ]
 
     def test_creation(self):
@@ -71,8 +70,13 @@ def test_absolute_volume(self):
         """Creates a set of pf coils using the PoloidalFieldCoilSet parametric
         component and checks that the volume is correct."""
 
-        assert self.test_shape.volume() == (pytest.approx((10 * 20 * math.pi * (2 * 100)) + (
-            15 * 25 * math.pi * (2 * 200)) + (5 * 30 * math.pi * (2 * 300))))
+        assert self.test_shape.volume() == (
+            pytest.approx(
+                (10 * 20 * math.pi * (2 * 100))
+                + (15 * 25 * math.pi * (2 * 200))
+                + (5 * 30 * math.pi * (2 * 300))
+            )
+        )
 
     def test_absolute_areas(self):
         """Creates a set of pf coils using the PoloidalFieldCoilSet parametric
@@ -80,24 +84,19 @@ def test_absolute_areas(self):
 
         assert len(self.test_shape.areas) == 12
         assert len(set(round(i) for i in self.test_shape.areas)) == 9
-        assert self.test_shape.areas.count(
-            pytest.approx(20 * math.pi * (2 * 100))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(25 * math.pi * (2 * 200))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(30 * math.pi * (2 * 300))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * (2 * 90))) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(10 * math.pi * (2 * 110))) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(15 * math.pi * (2 * 187.5))) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(15 * math.pi * (2 * 212.5))) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(5 * math.pi * (2 * 285))) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx(5 * math.pi * (2 * 315))) == 1
+        assert self.test_shape.areas.count(pytest.approx(20 * math.pi * (2 * 100))) == 2
+        assert self.test_shape.areas.count(pytest.approx(25 * math.pi * (2 * 200))) == 2
+        assert self.test_shape.areas.count(pytest.approx(30 * math.pi * (2 * 300))) == 2
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * (2 * 90))) == 1
+        assert self.test_shape.areas.count(pytest.approx(10 * math.pi * (2 * 110))) == 1
+        assert (
+            self.test_shape.areas.count(pytest.approx(15 * math.pi * (2 * 187.5))) == 1
+        )
+        assert (
+            self.test_shape.areas.count(pytest.approx(15 * math.pi * (2 * 212.5))) == 1
+        )
+        assert self.test_shape.areas.count(pytest.approx(5 * math.pi * (2 * 285))) == 1
+        assert self.test_shape.areas.count(pytest.approx(5 * math.pi * (2 * 315))) == 1
 
     def test_PoloidalFieldCoilSet_incorrect_height(self):
         """Checks that an error is raised when a PoloidalFieldCoilSet is made
@@ -107,12 +106,10 @@ def make_PoloidalFieldCoilSet_incorrect_height():
             paramak.PoloidalFieldCoilSet(
                 heights=10,
                 widths=[20, 20, 20],
-                center_points=[(100, 100), (200, 200), (300, 300)])
+                center_points=[(100, 100), (200, 200), (300, 300)],
+            )
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilSet_incorrect_height
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilSet_incorrect_height)
 
     def test_PoloidalFieldCoilSet_incorrect_width(self):
         """Checks that an error is raised when a PoloidalFieldCoilSet is made
@@ -122,12 +119,10 @@ def make_PoloidalFieldCoilSet_incorrect_width():
             paramak.PoloidalFieldCoilSet(
                 heights=[10, 10, 10],
                 widths=20,
-                center_points=[(100, 100), (200, 200), (300, 300)])
+                center_points=[(100, 100), (200, 200), (300, 300)],
+            )
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilSet_incorrect_width
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilSet_incorrect_width)
 
     def test_PoloidalFieldCoilSet_incorrect_center_points(self):
         """Checks that an error is raised when a PoloidalFieldCoilSet is made
@@ -135,14 +130,10 @@ def test_PoloidalFieldCoilSet_incorrect_center_points(self):
 
         def make_PoloidalFieldCoilSet_incorrect_center_points():
             paramak.PoloidalFieldCoilSet(
-                heights=[10, 10, 10],
-                widths=[20, 20, 20],
-                center_points=100)
+                heights=[10, 10, 10], widths=[20, 20, 20], center_points=100
+            )
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilSet_incorrect_center_points
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilSet_incorrect_center_points)
 
     def test_PoloidalFieldCoilSet_incorrect_width_length(self):
         """Checks that an error is raised when a PoloidalFieldCoilSet is made
@@ -152,9 +143,7 @@ def make_PoloidalFieldCoilSet_incorrect_width_length():
             paramak.PoloidalFieldCoilSet(
                 heights=[10, 10, 10],
                 widths=[20, 20],
-                center_points=[(100, 100), (200, 200), (300, 300)])
+                center_points=[(100, 100), (200, 200), (300, 300)],
+            )
 
-        self.assertRaises(
-            ValueError,
-            make_PoloidalFieldCoilSet_incorrect_width_length
-        )
+        self.assertRaises(ValueError, make_PoloidalFieldCoilSet_incorrect_width_length)
diff --git a/tests/test_parametric_components/test_poloidal_segments.py b/tests/test_parametric_components/test_poloidal_segments.py
index 58a0fc3d7..f91ec55dd 100644
--- a/tests/test_parametric_components/test_poloidal_segments.py
+++ b/tests/test_parametric_components/test_poloidal_segments.py
@@ -1,19 +1,15 @@
-
 import unittest
 
 import paramak
 
 
 class TestPoloidalSegments(unittest.TestCase):
-
     def test_solid_count_with_incorrect_input(self):
         """Checks the segmenter does not take a float as an input."""
 
         def create_shape():
             test_shape_to_segment = paramak.PoloidalFieldCoil(
-                height=100,
-                width=100,
-                center_point=(500, 500)
+                height=100, width=100, center_point=(500, 500)
             )
 
             paramak.PoloidalSegments(
@@ -22,17 +18,14 @@ def create_shape():
                 number_of_segments=22.5,
             )
 
-        self.assertRaises(
-            TypeError, create_shape)
+        self.assertRaises(TypeError, create_shape)
 
     def test_solid_count_with_incorrect_inputs2(self):
         """Checks the segmenter does not take a negative int as an input."""
 
         def create_shape():
             test_shape_to_segment = paramak.PoloidalFieldCoil(
-                height=100,
-                width=100,
-                center_point=(500, 500)
+                height=100, width=100, center_point=(500, 500)
             )
 
             paramak.PoloidalSegments(
@@ -41,22 +34,18 @@ def create_shape():
                 number_of_segments=-5,
             )
 
-        self.assertRaises(
-            ValueError, create_shape)
+        self.assertRaises(ValueError, create_shape)
 
     def test_solid_count(self):
         """Creates a rotated hollow ring and segments it into poloidal
         sections."""
 
         pf_coil = paramak.PoloidalFieldCoil(
-            height=100,
-            width=100,
-            center_point=(500, 500)
+            height=100, width=100, center_point=(500, 500)
         )
 
         test_shape_to_segment = paramak.PoloidalFieldCoilCaseFC(
-            pf_coil=pf_coil,
-            casing_thickness=100
+            pf_coil=pf_coil, casing_thickness=100
         )
 
         test_shape = paramak.PoloidalSegments(
@@ -72,9 +61,7 @@ def test_solid_count2(self):
         """Creates a rotated ring and segments it into poloidal sections."""
 
         test_shape_to_segment = paramak.PoloidalFieldCoil(
-            height=100,
-            width=100,
-            center_point=(500, 500)
+            height=100, width=100, center_point=(500, 500)
         )
 
         test_shape = paramak.PoloidalSegments(
@@ -87,8 +74,7 @@ def test_solid_count2(self):
         assert len(test_shape.solid.Solids()) == 22
 
     def test_without_shape_to_segment(self):
-        """Checks a solid can be created if no shape is given
-        """
+        """Checks a solid can be created if no shape is given"""
         test_shape = paramak.PoloidalSegments(
             shape_to_segment=None,
             center_point=(500, 500),
diff --git a/tests/test_parametric_components/test_poloidally_segmented_blanket_fp.py b/tests/test_parametric_components/test_poloidally_segmented_blanket_fp.py
index 02592d5e3..1a278f380 100644
--- a/tests/test_parametric_components/test_poloidally_segmented_blanket_fp.py
+++ b/tests/test_parametric_components/test_poloidally_segmented_blanket_fp.py
@@ -1,4 +1,3 @@
-
 import unittest
 
 import paramak
@@ -7,15 +6,15 @@
 class TestBlanketFP(unittest.TestCase):
     def test_creation(self):
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
         assert blanket.solid is not None
 
     def test_creation_with_optimiser(self):
         # Default
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
         assert blanket.solid is not None
 
         # With limits
@@ -36,8 +35,8 @@ def test_creation_with_optimiser(self):
 
     def test_optimiser(self):
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
 
         blanket.length_limits = (100, 300)
         blanket.nb_segments_limits = (2, 8)
@@ -55,13 +54,16 @@ def test_modifying_nb_segments_limits(self):
         also modifies segmets_angles accordingly
         """
         blanket1 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
 
         blanket2 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180,
-            cut=blanket1)
+            thickness=20,
+            start_angle=0,
+            stop_angle=180,
+            rotation_angle=180,
+            cut=blanket1,
+        )
 
         blanket1.nb_segments_limits = (4, 8)
         blanket2.nb_segments_limits = (3, 8)
@@ -70,13 +72,16 @@ def test_modifying_nb_segments_limits(self):
 
     def test_segments_angles_is_modified_num_segments(self):
         blanket1 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
 
         blanket2 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180,
-            cut=blanket1)
+            thickness=20,
+            start_angle=0,
+            stop_angle=180,
+            rotation_angle=180,
+            cut=blanket1,
+        )
 
         blanket1.num_segments = 8
         blanket2.num_segments = 5
@@ -84,27 +89,30 @@ def test_segments_angles_is_modified_num_segments(self):
 
     def test_num_point_is_affected(self):
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
         assert blanket.num_points == blanket.num_segments + 1
         blanket.num_segments = 60
         assert blanket.num_points == blanket.num_segments + 1
 
     def test_segment_angles_affects_solid(self):
         blanket1 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180)
+            thickness=20, start_angle=0, stop_angle=180, rotation_angle=180
+        )
         blanket2 = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180,
-            cut=blanket1)
+            thickness=20,
+            start_angle=0,
+            stop_angle=180,
+            rotation_angle=180,
+            cut=blanket1,
+        )
         blanket2.segments_angles = [0, 25, 50, 90, 130, 150, 180]
         assert blanket2.volume() != 0
 
     def test_warning_segment_angles(self):
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=1,
-            stop_angle=50, rotation_angle=180)
+            thickness=20, start_angle=1, stop_angle=50, rotation_angle=180
+        )
 
         def warning1():
             blanket.start_angle = 1
@@ -123,8 +131,10 @@ def warning2():
 
     def test_creation_with_gaps(self):
         blanket = paramak.BlanketFPPoloidalSegments(
-            thickness=20, start_angle=0,
-            stop_angle=180, rotation_angle=180,
-            segments_gap=3
+            thickness=20,
+            start_angle=0,
+            stop_angle=180,
+            rotation_angle=180,
+            segments_gap=3,
         )
         assert blanket.solid is not None
diff --git a/tests/test_parametric_components/test_port_cutter_circular.py b/tests/test_parametric_components/test_port_cutter_circular.py
index 1df2fcb55..5baa0f9c6 100644
--- a/tests/test_parametric_components/test_port_cutter_circular.py
+++ b/tests/test_parametric_components/test_port_cutter_circular.py
@@ -1,17 +1,14 @@
 import math
 import unittest
 
-import paramak
-
 import pytest
 
+import paramak
 
-class TestPortCutterCircular(unittest.TestCase):
 
+class TestPortCutterCircular(unittest.TestCase):
     def setUp(self):
-        self.test_shape = paramak.PortCutterCircular(
-            distance=300, radius=20
-        )
+        self.test_shape = paramak.PortCutterCircular(distance=300, radius=20)
 
     def test_default_parameters(self):
         """Checks that the default parameters of a PortCutterCircular are correct."""
@@ -43,11 +40,10 @@ def test_relative_volume(self):
     def test_absolute_volume(self):
         """Creates a PortCutterCircular shape and checks that its volume is correct."""
 
-        assert self.test_shape.volume() == pytest.approx(math.pi * (20**2) * 300)
+        assert self.test_shape.volume() == pytest.approx(math.pi * (20 ** 2) * 300)
 
         self.test_shape.extrusion_start_offset = 20
         self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]
         self.test_shape.radius = 10
 
-        assert self.test_shape.volume() == pytest.approx(
-            math.pi * (10**2) * 300 * 4)
+        assert self.test_shape.volume() == pytest.approx(math.pi * (10 ** 2) * 300 * 4)
diff --git a/tests/test_parametric_components/test_port_cutter_rectangular.py b/tests/test_parametric_components/test_port_cutter_rectangular.py
index 888f151e1..5ce707204 100644
--- a/tests/test_parametric_components/test_port_cutter_rectangular.py
+++ b/tests/test_parametric_components/test_port_cutter_rectangular.py
@@ -1,13 +1,11 @@
-
 import unittest
 
-import paramak
-
 import pytest
 
+import paramak
 
-class TestPortCutterRectangular(unittest.TestCase):
 
+class TestPortCutterRectangular(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.PortCutterRectangular(
             width=20, height=40, distance=300
diff --git a/tests/test_parametric_components/test_port_cutter_rotated.py b/tests/test_parametric_components/test_port_cutter_rotated.py
index 2ed8b41af..95c19a846 100644
--- a/tests/test_parametric_components/test_port_cutter_rotated.py
+++ b/tests/test_parametric_components/test_port_cutter_rotated.py
@@ -1,7 +1,7 @@
-
 import unittest
 
 import numpy as np
+
 import paramak
 
 
@@ -15,7 +15,7 @@ def test_shape_construction_and_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         large_ports = paramak.PortCutterRotated(
@@ -24,27 +24,19 @@ def test_shape_construction_and_volume(self):
             polar_placement_angle=10,
             azimuth_placement_angle=np.linspace(0, 360, 4),
             max_distance_from_center=1000,
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         vessel_with_out_ports = paramak.CenterColumnShieldCylinder(
-            height=500,
-            inner_radius=200,
-            outer_radius=300
+            height=500, inner_radius=200, outer_radius=300
         )
 
         vessel_with_small_ports = paramak.CenterColumnShieldCylinder(
-            height=500,
-            inner_radius=200,
-            outer_radius=300,
-            cut=small_ports
+            height=500, inner_radius=200, outer_radius=300, cut=small_ports
         )
 
         vessel_with_large_ports = paramak.CenterColumnShieldCylinder(
-            height=500,
-            inner_radius=200,
-            outer_radius=300,
-            cut=large_ports
+            height=500, inner_radius=200, outer_radius=300, cut=large_ports
         )
 
         assert large_ports.volume() > small_ports.volume()
@@ -61,7 +53,7 @@ def test_polar_coverage_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         large_ports = paramak.PortCutterRotated(
@@ -70,7 +62,7 @@ def test_polar_coverage_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         assert large_ports.volume() > small_ports.volume()
@@ -85,7 +77,7 @@ def test_max_distance_from_center_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         large_ports = paramak.PortCutterRotated(
@@ -94,7 +86,7 @@ def test_max_distance_from_center_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=2000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         assert large_ports.volume() > small_ports.volume()
@@ -109,7 +101,7 @@ def test_azimuth_placement_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         large_ports = paramak.PortCutterRotated(
@@ -118,7 +110,7 @@ def test_azimuth_placement_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 5),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         assert large_ports.volume() > small_ports.volume()
@@ -133,7 +125,7 @@ def test_rotation_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=10
+            rotation_angle=10,
         )
 
         large_ports = paramak.PortCutterRotated(
@@ -142,7 +134,7 @@ def test_rotation_angle_impacts_volume(self):
             polar_placement_angle=10,
             max_distance_from_center=1000,
             azimuth_placement_angle=np.linspace(0, 360, 4),
-            rotation_angle=20
+            rotation_angle=20,
         )
 
         assert large_ports.volume() > small_ports.volume()
@@ -150,6 +142,7 @@ def test_rotation_angle_impacts_volume(self):
     def test_outerpoint_negative(self):
         """Tests that when polar_coverage_angle is greater than 180 an error is
         raised."""
+
         def error():
             paramak.PortCutterRotated(
                 center_point=(1, 1),
@@ -157,4 +150,5 @@ def error():
                 polar_placement_angle=0,
                 rotation_angle=10,
             )
+
         self.assertRaises(ValueError, error)
diff --git a/tests/test_parametric_components/test_rotated_isosceles_triangle.py b/tests/test_parametric_components/test_rotated_isosceles_triangle.py
index 798092498..d8b4df2af 100644
--- a/tests/test_parametric_components/test_rotated_isosceles_triangle.py
+++ b/tests/test_parametric_components/test_rotated_isosceles_triangle.py
@@ -1,13 +1,11 @@
-
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestRotatedIsoscelesTriangle(unittest.TestCase):
 
+class TestRotatedIsoscelesTriangle(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.RotatedIsoscelesTriangle(
             height=10,
@@ -41,15 +39,11 @@ def test_args_do_not_impact_volume(self):
 
         self.test_shape.pivot_angle = 180
 
-        assert pytest.approx(
-            self.test_shape.volume(),
-            rel=0.01) == test_shape_vol
+        assert pytest.approx(self.test_shape.volume(), rel=0.01) == test_shape_vol
 
         self.test_shape.pivot_point = (100, 300)
 
-        assert pytest.approx(
-            self.test_shape.volume(),
-            rel=0.01) == test_shape_vol
+        assert pytest.approx(self.test_shape.volume(), rel=0.01) == test_shape_vol
 
     def test_args_impact_volume(self):
         """Changes args that should impact the volume and checks that the
diff --git a/tests/test_parametric_components/test_rotated_trapezoid.py b/tests/test_parametric_components/test_rotated_trapezoid.py
index 873250de9..fdefa2bf9 100644
--- a/tests/test_parametric_components/test_rotated_trapezoid.py
+++ b/tests/test_parametric_components/test_rotated_trapezoid.py
@@ -1,13 +1,11 @@
-
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestRotatedTrapezoid(unittest.TestCase):
 
+class TestRotatedTrapezoid(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.RotatedTrapezoid(
             length_1=10,
@@ -42,15 +40,11 @@ def test_args_do_not_impact_volume(self):
 
         self.test_shape.pivot_angle = 180
 
-        assert pytest.approx(
-            self.test_shape.volume(),
-            rel=0.01) == test_shape_vol
+        assert pytest.approx(self.test_shape.volume(), rel=0.01) == test_shape_vol
 
         self.test_shape.pivot_point = (100, 300)
 
-        assert pytest.approx(
-            self.test_shape.volume(),
-            rel=0.01) == test_shape_vol
+        assert pytest.approx(self.test_shape.volume(), rel=0.01) == test_shape_vol
 
     def test_args_impact_volume(self):
         """Changes args that should impact the volume and checks that the
diff --git a/tests/test_parametric_components/test_shell_fs.py b/tests/test_parametric_components/test_shell_fs.py
index 82fbed98e..97ffb36fd 100644
--- a/tests/test_parametric_components/test_shell_fs.py
+++ b/tests/test_parametric_components/test_shell_fs.py
@@ -1,27 +1,21 @@
-
 import unittest
 
 import paramak
 
 
 class TestShellFS(unittest.TestCase):
-
     def setUp(self):
         # this is the shape that gets shelled
         self.test_shape = paramak.PoloidalFieldCoil(
-            height=50,
-            width=50,
-            rotation_angle=90,
-            center_point=(100, 100)
+            height=50, width=50, rotation_angle=90, center_point=(100, 100)
         )
 
     def test_creation_with_different_kinds(self):
 
-        casing_int = paramak.ShellFS(
-            shape=self.test_shape, kind='intersection')
-        casing_int.export_stp('int.stp')
-        casing_arc = paramak.ShellFS(shape=self.test_shape, kind='arc')
-        casing_arc.export_stp('arc.stp')
+        casing_int = paramak.ShellFS(shape=self.test_shape, kind="intersection")
+        casing_int.export_stp("int.stp")
+        casing_arc = paramak.ShellFS(shape=self.test_shape, kind="arc")
+        casing_arc.export_stp("arc.stp")
 
         assert casing_int.solid is not None
         assert casing_int.solid is not None
diff --git a/tests/test_parametric_components/test_test_tf_coil_casing.py b/tests/test_parametric_components/test_test_tf_coil_casing.py
index 49f859eec..59fb7f299 100644
--- a/tests/test_parametric_components/test_test_tf_coil_casing.py
+++ b/tests/test_parametric_components/test_test_tf_coil_casing.py
@@ -1,4 +1,3 @@
-
 import os
 import unittest
 from pathlib import Path
@@ -7,7 +6,6 @@
 
 
 class TestTFCoilCasing(unittest.TestCase):
-
     def setUp(self):
         inner_offset = 10
         outer_offset = 10
@@ -18,13 +16,20 @@ def setUp(self):
 
         # create a princeton D magnet
         magnet = paramak.ToroidalFieldCoilPrincetonD(
-            R1=100, R2=200, thickness=magnet_thickness,
-            distance=magnet_extrude_distance, number_of_coils=1)
+            R1=100,
+            R2=200,
+            thickness=magnet_thickness,
+            distance=magnet_extrude_distance,
+            number_of_coils=1,
+        )
 
         self.test_shape = paramak.TFCoilCasing(
-            magnet=magnet, distance=casing_extrude_distance,
-            inner_offset=inner_offset, outer_offset=outer_offset,
-            vertical_section_offset=vertical_section_offset)
+            magnet=magnet,
+            distance=casing_extrude_distance,
+            inner_offset=inner_offset,
+            outer_offset=outer_offset,
+            vertical_section_offset=vertical_section_offset,
+        )
 
     def test_creation(self):
 
@@ -36,17 +41,21 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
diff --git a/tests/test_parametric_components/test_toroidal_field_coil_coat_hanger.py b/tests/test_parametric_components/test_toroidal_field_coil_coat_hanger.py
index 99569e772..f36223b2c 100644
--- a/tests/test_parametric_components/test_toroidal_field_coil_coat_hanger.py
+++ b/tests/test_parametric_components/test_toroidal_field_coil_coat_hanger.py
@@ -1,8 +1,9 @@
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestToroidalFieldCoilCoatHanger(unittest.TestCase):
     def setUp(self):
diff --git a/tests/test_parametric_components/test_toroidal_field_coil_princetond.py b/tests/test_parametric_components/test_toroidal_field_coil_princetond.py
index f34be4731..501c3a9fe 100644
--- a/tests/test_parametric_components/test_toroidal_field_coil_princetond.py
+++ b/tests/test_parametric_components/test_toroidal_field_coil_princetond.py
@@ -1,16 +1,19 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestToroidalFieldCoilPrincetonD(unittest.TestCase):
 
+class TestToroidalFieldCoilPrincetonD(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.ToroidalFieldCoilPrincetonD(
-            R1=100, R2=300, thickness=50, distance=30, number_of_coils=1,
-            with_inner_leg=True
+            R1=100,
+            R2=300,
+            thickness=50,
+            distance=30,
+            number_of_coils=1,
+            with_inner_leg=True,
         )
 
     def test_default_parameters(self):
@@ -57,8 +60,7 @@ def test_relative_volume(self):
         test_volume = self.test_shape.volume()
 
         self.test_shape.number_of_coils = 8
-        assert test_volume == pytest.approx(
-            self.test_shape.volume() * 0.5, rel=0.01)
+        assert test_volume == pytest.approx(self.test_shape.volume() * 0.5, rel=0.01)
 
     def test_rotation_angle(self):
         """Creates a tf coil with a rotation_angle < 360 degrees and checks
@@ -70,20 +72,17 @@ def test_rotation_angle(self):
         self.test_shape.workplane = "XZ"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
         self.test_shape.rotation_angle = 360
         self.test_shape.workplane = "YZ"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
         self.test_shape.rotation_angle = 360
         self.test_shape.workplane = "XY"
         self.test_shape.rotation_axis = "Y"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
diff --git a/tests/test_parametric_components/test_toroidal_field_coil_rectangle.py b/tests/test_parametric_components/test_toroidal_field_coil_rectangle.py
index a50ceda28..533809c5b 100644
--- a/tests/test_parametric_components/test_toroidal_field_coil_rectangle.py
+++ b/tests/test_parametric_components/test_toroidal_field_coil_rectangle.py
@@ -1,12 +1,11 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestToroidalFieldCoilRectangle(unittest.TestCase):
 
+class TestToroidalFieldCoilRectangle(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.ToroidalFieldCoilRectangle(
             horizontal_start_point=(100, 700),
@@ -14,7 +13,7 @@ def setUp(self):
             thickness=50,
             distance=30,
             number_of_coils=1,
-            with_inner_leg=True
+            with_inner_leg=True,
         )
 
     def test_default_parameters(self):
@@ -37,7 +36,7 @@ def test_points_calculation(self):
             (100, -750),
             (850, -750),
             (850, 750),
-            (100, 750)
+            (100, 750),
         ]
 
     def test_processed_points_calculation(self):
@@ -45,17 +44,17 @@ def test_processed_points_calculation(self):
         calculated correctly from the parameters given."""
 
         assert self.test_shape.processed_points == [
-            (100, 700, 'straight'),
-            (150, 700, 'straight'),
-            (800, 700, 'straight'),
-            (800, -700, 'straight'),
-            (150, -700, 'straight'),
-            (100, -700, 'straight'),
-            (100, -750, 'straight'),
-            (850, -750, 'straight'),
-            (850, 750, 'straight'),
-            (100, 750, 'straight'),
-            (100, 700, 'straight')
+            (100, 700, "straight"),
+            (150, 700, "straight"),
+            (800, 700, "straight"),
+            (800, -700, "straight"),
+            (150, -700, "straight"),
+            (100, -700, "straight"),
+            (100, -750, "straight"),
+            (850, -750, "straight"),
+            (850, 750, "straight"),
+            (100, 750, "straight"),
+            (100, 700, "straight"),
         ]
 
     def test_creation_with_inner_leg(self):
@@ -87,15 +86,15 @@ def test_creation_with_inner_leg_with_overlap(self):
         assert self.test_shape.solid is not None
 
         test_inner_leg = paramak.ExtrudeStraightShape(
-            points=[
-                (0, 700), (50, 700), (50, -700), (0, -700)
-            ], distance=30,
-            azimuth_placement_angle=[0, 45, 90, 135, 180, 225, 270, 315]
+            points=[(0, 700), (50, 700), (50, -700), (0, -700)],
+            distance=30,
+            azimuth_placement_angle=[0, 45, 90, 135, 180, 225, 270, 315],
         )
         inner_leg_volume = test_inner_leg.volume()
 
         assert with_inner_leg_volume == pytest.approx(
-            without_inner_leg_volume + inner_leg_volume)
+            without_inner_leg_volume + inner_leg_volume
+        )
 
     def test_creation_no_inner_leg(self):
         """Creates a tf coil with no inner leg using the ToroidalFieldCoilRectangle
@@ -110,8 +109,7 @@ def test_creation_no_inner_leg(self):
 
         self.test_shape.with_inner_leg = False
         assert self.test_shape.solid is not None
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume - inner_leg_volume)
+        assert self.test_shape.volume() == pytest.approx(test_volume - inner_leg_volume)
 
     def test_absolute_volume(self):
         """Creates a tf coil using the ToroidalFieldCoilRectangle parametric
@@ -121,11 +119,13 @@ def test_absolute_volume(self):
         self.test_shape.distance = 50
 
         assert self.test_shape.volume() == pytest.approx(
-            (850 * 150 * 50 * 2) + (1400 * 150 * 50 * 2))
+            (850 * 150 * 50 * 2) + (1400 * 150 * 50 * 2)
+        )
 
         self.test_shape.with_inner_leg = False
         assert self.test_shape.volume() == pytest.approx(
-            (850 * 150 * 50 * 2) + (1400 * 150 * 50))
+            (850 * 150 * 50 * 2) + (1400 * 150 * 50)
+        )
 
         self.test_shape.with_inner_leg = True
         self.test_shape.number_of_coils = 8
@@ -145,11 +145,20 @@ def test_absolute_areas(self):
         self.test_shape.thickness = 150
         self.test_shape.distance = 50
 
-        assert self.test_shape.area == pytest.approx((((850 * 150 * 2) + (1400 * 150)) * 2) + (
-            1400 * 150 * 2) + (850 * 50 * 2) + (1700 * 50) + (1400 * 50 * 3) + (700 * 50 * 2) + (150 * 50 * 4))
+        assert self.test_shape.area == pytest.approx(
+            (((850 * 150 * 2) + (1400 * 150)) * 2)
+            + (1400 * 150 * 2)
+            + (850 * 50 * 2)
+            + (1700 * 50)
+            + (1400 * 50 * 3)
+            + (700 * 50 * 2)
+            + (150 * 50 * 4)
+        )
         assert len(self.test_shape.areas) == 16
-        assert self.test_shape.areas.count(pytest.approx(
-            (850 * 150 * 2) + (1400 * 150))) == 2
+        assert (
+            self.test_shape.areas.count(pytest.approx((850 * 150 * 2) + (1400 * 150)))
+            == 2
+        )
         assert self.test_shape.areas.count(pytest.approx((1400 * 150))) == 2
         assert self.test_shape.areas.count(pytest.approx(850 * 50)) == 2
         assert self.test_shape.areas.count(pytest.approx(1700 * 50)) == 1
@@ -158,8 +167,14 @@ def test_absolute_areas(self):
         assert self.test_shape.areas.count(pytest.approx(150 * 50)) == 4
 
         self.test_shape.with_inner_leg = False
-        assert self.test_shape.area == pytest.approx((((850 * 150 * 2) + (1400 * 150)) * 2) + (
-            850 * 50 * 2) + (1700 * 50) + (1400 * 50) + (700 * 50 * 2) + (150 * 50 * 2))
+        assert self.test_shape.area == pytest.approx(
+            (((850 * 150 * 2) + (1400 * 150)) * 2)
+            + (850 * 50 * 2)
+            + (1700 * 50)
+            + (1400 * 50)
+            + (700 * 50 * 2)
+            + (150 * 50 * 2)
+        )
 
     def test_rotation_angle(self):
         """Creates tf coils with rotation_angles < 360 degrees in different
@@ -197,8 +212,7 @@ def make_ToroidalFieldCoilRectangle_incorrect_horizontal_start_point():
             self.test_shape.solid
 
         self.assertRaises(
-            ValueError,
-            make_ToroidalFieldCoilRectangle_incorrect_horizontal_start_point
+            ValueError, make_ToroidalFieldCoilRectangle_incorrect_horizontal_start_point
         )
 
     def test_ToroidalFieldCoilRectangle_incorrect_vertical_mid_point(self):
@@ -211,6 +225,5 @@ def make_ToroidalFieldCoilRectangle_incorrect_vertical_mid_point():
             self.test_shape.solid
 
         self.assertRaises(
-            ValueError,
-            make_ToroidalFieldCoilRectangle_incorrect_vertical_mid_point
+            ValueError, make_ToroidalFieldCoilRectangle_incorrect_vertical_mid_point
         )
diff --git a/tests/test_parametric_components/test_toroidal_field_coil_rectangle_round_corner.py b/tests/test_parametric_components/test_toroidal_field_coil_rectangle_round_corner.py
index 65060ec05..f89a397bb 100644
--- a/tests/test_parametric_components/test_toroidal_field_coil_rectangle_round_corner.py
+++ b/tests/test_parametric_components/test_toroidal_field_coil_rectangle_round_corner.py
@@ -1,8 +1,8 @@
-
 from math import pi
 
 import pytest
 from attr.setters import NO_OP
+
 from paramak import ToroidalFieldCoilRectangleRoundCorners
 
 obj = ToroidalFieldCoilRectangleRoundCorners(
@@ -11,7 +11,7 @@
     thickness=20,
     distance=10,
     number_of_coils=1,
-    with_inner_leg=False
+    with_inner_leg=False,
 )
 
 obj2 = ToroidalFieldCoilRectangleRoundCorners(
@@ -20,18 +20,19 @@
     thickness=20,
     distance=10,
     number_of_coils=1,
-    with_inner_leg=True
+    with_inner_leg=True,
 )
 
 
 def surface_area(
-        lower_left,
-        middle_right,
-        thickness,
-        extrusion_length,
-        with_inner_leg=False,
-        xz_face_only=False,
-        extrusion_area_only=False):
+    lower_left,
+    middle_right,
+    thickness,
+    extrusion_length,
+    with_inner_leg=False,
+    xz_face_only=False,
+    extrusion_area_only=False,
+):
     """
     Function calculates the total surface area of the TF coil from the
     coordinates given in the find_points function
@@ -42,7 +43,7 @@ def surface_area(
         thickness=thickness,
         distance=extrusion_length,
         number_of_coils=1,
-        with_inner_leg=with_inner_leg
+        with_inner_leg=with_inner_leg,
     )
 
     analyse_attributes = test_object.analyse_attributes
@@ -52,14 +53,14 @@ def surface_area(
     # The surface area of the face in XZ plane is divisible into 5 segments
     base_segment_area = thickness * (base - inner_rad)
     vertical_segment_area = thickness * (height - (inner_rad * 2))
-    corner_area = (pi / 4) * (outter_rad**2 - inner_rad**2)
+    corner_area = (pi / 4) * (outter_rad ** 2 - inner_rad ** 2)
 
     # XZ plane face area
-    total_face_area = base_segment_area * 2 + \
-        vertical_segment_area + corner_area * 2
+    total_face_area = base_segment_area * 2 + vertical_segment_area + corner_area * 2
     # The surface area of the planes in YZ plane
-    contour_length = inner_rad * \
-        (pi - 8) + pi * outter_rad + 2 * (2 * base + thickness + height)
+    contour_length = (
+        inner_rad * (pi - 8) + pi * outter_rad + 2 * (2 * base + thickness + height)
+    )
     extrusion_area = contour_length * extrusion_length
     # Total Area
     total_bounding_surface = total_face_area * 2 + extrusion_area
@@ -68,13 +69,19 @@ def surface_area(
         # XZ plane face area
         total_face_area += thickness * height
         print(total_face_area)
-        total_leg_surface_area = 2 * height * thickness + 2 * \
-            extrusion_length * height + 2 * extrusion_length * thickness
+        total_leg_surface_area = (
+            2 * height * thickness
+            + 2 * extrusion_length * height
+            + 2 * extrusion_length * thickness
+        )
 
         # Total bounding surface
         total_bounding_surface += total_leg_surface_area
-        print("Face area: {}\nExtrusion Ares: {}\ntotal bounding area: {}"
-              .format(total_face_area, extrusion_area, total_bounding_surface))
+        print(
+            "Face area: {}\nExtrusion Ares: {}\ntotal bounding area: {}".format(
+                total_face_area, extrusion_area, total_bounding_surface
+            )
+        )
 
     if xz_face_only:
         return total_face_area
@@ -86,11 +93,11 @@ def surface_area(
 
 
 def volume(
-        lower_left,
-        middle_right,
-        thickness,
-        extrusion_length,
-        with_inner_leg=False,
+    lower_left,
+    middle_right,
+    thickness,
+    extrusion_length,
+    with_inner_leg=False,
 ):
     """
     The function calculates the volume from the given coordinates used for
@@ -105,7 +112,8 @@ def volume(
         thickness,
         extrusion_length,
         xz_face_only=True,
-        with_inner_leg=with_inner_leg)
+        with_inner_leg=with_inner_leg,
+    )
     print(face_area)
     total_shape_volume = face_area * extrusion_length
 
@@ -114,11 +122,11 @@ def volume(
 
 # Parametric Tests
 
+
 @pytest.mark.parametric
 def test_parametric_surface_area_with_leg():
     paramak_area = obj2.area
-    package_area = surface_area(
-        (50, 0), (100, 100), 20, 10, with_inner_leg=True)
+    package_area = surface_area((50, 0), (100, 100), 20, 10, with_inner_leg=True)
     assert pytest.approx(package_area) == paramak_area
 
 
@@ -145,6 +153,7 @@ def test_parametric_volume():
 
 # Analytical Tests
 
+
 @pytest.mark.analytical
 def test_manual_area():
     analytical = 19872.92
@@ -162,6 +171,7 @@ def test_manual_volume():
 # Input Parameter Tests
 # Lower Point Coordinate
 
+
 @pytest.mark.dtype
 def test_input_param_lower_inner():
     with pytest.raises(TypeError):
@@ -227,6 +237,7 @@ def test_lower_point_setter_elements_x():
 
 # Mid Point Coordinate
 
+
 @pytest.mark.dtype
 def test_input_param_mid_point():
     with pytest.raises(TypeError):
@@ -292,6 +303,7 @@ def test_mid_point_setter_elements_x():
 
 # Coordinate Comparison
 
+
 @pytest.mark.value
 def test_input_x_coordinates():
     with pytest.raises(ValueError):
@@ -314,6 +326,7 @@ def test_x_coords_with_setters():
 
 # Thickness Parameter
 
+
 @pytest.mark.dtype
 def test_input_param_thickness():
     with pytest.raises(TypeError):
@@ -353,6 +366,7 @@ def test_thickness_setter():
 
 # Extrusion Distance
 
+
 @pytest.mark.dtype
 def test_input_param_distance():
     with pytest.raises(TypeError):
@@ -374,6 +388,7 @@ def test_distance_setter():
 
 # Number of Coils
 
+
 @pytest.mark.value
 def test_input_num_coils():
     with pytest.raises(TypeError):
diff --git a/tests/test_parametric_components/test_toroidal_field_coil_triple_arc.py b/tests/test_parametric_components/test_toroidal_field_coil_triple_arc.py
index 79a757952..811f651fc 100644
--- a/tests/test_parametric_components/test_toroidal_field_coil_triple_arc.py
+++ b/tests/test_parametric_components/test_toroidal_field_coil_triple_arc.py
@@ -1,16 +1,20 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
 
-class TestToroidalFieldCoilTripleArc(unittest.TestCase):
 
+class TestToroidalFieldCoilTripleArc(unittest.TestCase):
     def setUp(self):
         self.test_shape = paramak.ToroidalFieldCoilTripleArc(
-            R1=100, h=100, radii=(100, 200), coverages=(10, 60), thickness=10,
-            distance=50, number_of_coils=1,
+            R1=100,
+            h=100,
+            radii=(100, 200),
+            coverages=(10, 60),
+            thickness=10,
+            distance=50,
+            number_of_coils=1,
         )
 
     def test_default_parameters(self):
@@ -47,8 +51,7 @@ def test_creation_no_inner_leg(self):
         self.test_shape.with_inner_leg = False
 
         assert self.test_shape.solid is not None
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume - inner_leg_volume)
+        assert self.test_shape.volume() == pytest.approx(test_volume - inner_leg_volume)
 
     def test_relative_volume(self):
         """Creates tf coil shapes with different numbers of tf coils and checks that
@@ -58,8 +61,7 @@ def test_relative_volume(self):
 
         self.test_shape.number_of_coils = 8
 
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 8, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 8, rel=0.01)
 
     def test_rotation_angle(self):
         """Creates tf coils with rotation_angles < 360 in different workplanes
@@ -72,20 +74,17 @@ def test_rotation_angle(self):
         self.test_shape.workplane = "XZ"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
         self.test_shape.rotation_angle = 360
         self.test_shape.workplane = "YZ"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
         self.test_shape.rotation_angle = 360
         self.test_shape.workplane = "XY"
         self.test_shape.rotation_axis = "Y"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
diff --git a/tests/test_parametric_components/test_vacuum_vessel.py b/tests/test_parametric_components/test_vacuum_vessel.py
index 750c678ee..295e1d794 100644
--- a/tests/test_parametric_components/test_vacuum_vessel.py
+++ b/tests/test_parametric_components/test_vacuum_vessel.py
@@ -1,15 +1,11 @@
-
 import unittest
 
 import paramak
 
 
 class TestVacuumVessel(unittest.TestCase):
-
     def setUp(self):
-        self.test_shape = paramak.VacuumVessel(
-            height=2, inner_radius=1, thickness=0.2
-        )
+        self.test_shape = paramak.VacuumVessel(height=2, inner_radius=1, thickness=0.2)
 
     def test_creation(self):
         """Creates a shape using the VacuumVessel parametric component and
@@ -22,24 +18,23 @@ def test_ports(self):
         caquery solid is created."""
 
         cutter1 = paramak.PortCutterRectangular(
-            distance=3, center_point=(
-                0, 0), height=0.2, width=0.4, fillet_radius=0.01)
+            distance=3, center_point=(0, 0), height=0.2, width=0.4, fillet_radius=0.01
+        )
         cutter2 = paramak.PortCutterRectangular(
-            distance=3, center_point=(
-                0.5, 0), height=0.2, width=0.4, fillet_radius=0.00)
+            distance=3, center_point=(0.5, 0), height=0.2, width=0.4, fillet_radius=0.00
+        )
         cutter3 = paramak.PortCutterRectangular(
-            distance=3, center_point=(-0.5, 0), height=0.2, width=0.4)
+            distance=3, center_point=(-0.5, 0), height=0.2, width=0.4
+        )
         cutter4 = paramak.PortCutterCircular(
             distance=3,
-            center_point=(
-                0.25,
-                0),
+            center_point=(0.25, 0),
             radius=0.1,
             azimuth_placement_angle=45,
         )
         cutter5 = paramak.PortCutterRotated(
-            (0, 0), azimuth_placement_angle=-90, rotation_angle=10,
-            fillet_radius=0.01)
+            (0, 0), azimuth_placement_angle=-90, rotation_angle=10, fillet_radius=0.01
+        )
 
         pre_cut_volume = self.test_shape.volume()
 
diff --git a/tests/test_parametric_components/test_vacuum_vessel_inner_leg.py b/tests/test_parametric_components/test_vacuum_vessel_inner_leg.py
index 2ba56cb35..066110a8d 100644
--- a/tests/test_parametric_components/test_vacuum_vessel_inner_leg.py
+++ b/tests/test_parametric_components/test_vacuum_vessel_inner_leg.py
@@ -1,21 +1,18 @@
-
 import unittest
+
 import pytest
+
 import paramak
 
 
 class TestVacuumVessel(unittest.TestCase):
-
     def setUp(self):
         self.cutter = paramak.PortCutterRectangular(
             width=100,
             height=100,
             distance=1100,
-            azimuth_placement_angle=[
-                0,
-                90,
-                180,
-                270])
+            azimuth_placement_angle=[0, 90, 180, 270],
+        )
         self.test_shape = paramak.VacuumVesselInnerLeg(
             inner_height=1100,
             inner_radius=700,
@@ -27,7 +24,7 @@ def setUp(self):
             inner_radius=700,
             inner_leg_radius=100,
             thickness=100,
-            cut=self.cutter
+            cut=self.cutter,
         )
 
     def test_creation(self):
diff --git a/tests/test_parametric_reactors/test_ball_reactor.py b/tests/test_parametric_reactors/test_ball_reactor.py
index dc9cff5eb..6ec9c8d64 100644
--- a/tests/test_parametric_reactors/test_ball_reactor.py
+++ b/tests/test_parametric_reactors/test_ball_reactor.py
@@ -1,4 +1,3 @@
-
 import os
 import time
 import unittest
@@ -81,6 +80,7 @@ def test_rotation_angle_error(self):
 
         def invalid_rotation_angle():
             self.test_reactor.rotation_angle = 361
+
         self.assertRaises(ValueError, invalid_rotation_angle)
 
     def test_pf_coil_thicknesses_error(self):
@@ -89,10 +89,12 @@ def test_pf_coil_thicknesses_error(self):
 
         def invalid_pf_coil_radial_thicknesses():
             self.test_reactor.pf_coil_radial_thicknesses = 2
+
         self.assertRaises(ValueError, invalid_pf_coil_radial_thicknesses)
 
         def invalid_pf_coil_vertical_thicknesses():
             self.test_reactor.pf_coil_vertical_thicknesses = 2
+
         self.assertRaises(ValueError, invalid_pf_coil_vertical_thicknesses)
 
     def test_with_pf_and_tf_coils(self):
@@ -123,8 +125,10 @@ def warning_trigger():
             warning_trigger()
             assert len(w) == 1
             assert issubclass(w[-1].category, UserWarning)
-            assert "360 degree rotation may result in a Standard_ConstructionError or AttributeError" in str(
-                w[-1].message)
+            assert (
+                "360 degree rotation may result in a Standard_ConstructionError or AttributeError"
+                in str(w[-1].message)
+            )
 
     def test_ball_reactor_hash_value(self):
         """Creates a ball reactor and checks that all shapes in the reactor are
@@ -157,7 +161,7 @@ def test_ball_reactor_hash_value(self):
             "_blanket_rear_wall",
             "_pf_coil",
             "_pf_coils_casing",
-            "_tf_coil"
+            "_tf_coil",
         ]:
             assert key not in self.test_reactor.__dict__.keys()
         assert self.test_reactor.shapes_and_components is not None
@@ -172,7 +176,7 @@ def test_ball_reactor_hash_value(self):
             "_blanket_rear_wall",
             "_pf_coil",
             "_pf_coils_casing",
-            "_tf_coil"
+            "_tf_coil",
         ]:
             assert key in self.test_reactor.__dict__.keys()
         assert len(self.test_reactor.shapes_and_components) == 10
@@ -245,15 +249,9 @@ def test_export_stp(self):
         os.system("rm reactor_solids.stp")
         os.system("rm reactor_wires.stp")
 
-        self.test_reactor.export_stp(
-            filename='reactor_solid.stp',
-            mode='solid'
-        )
+        self.test_reactor.export_stp(filename="reactor_solid.stp", mode="solid")
 
-        self.test_reactor.export_stp(
-            filename='reactor_wires.stp',
-            mode='wire'
-        )
+        self.test_reactor.export_stp(filename="reactor_wires.stp", mode="wire")
 
         assert Path("reactor_solid.stp").is_file()
         assert Path("reactor_wires.stp").is_file()
diff --git a/tests/test_parametric_reactors/test_center_column_study_reactor.py b/tests/test_parametric_reactors/test_center_column_study_reactor.py
index 2713a22d0..30225a06b 100644
--- a/tests/test_parametric_reactors/test_center_column_study_reactor.py
+++ b/tests/test_parametric_reactors/test_center_column_study_reactor.py
@@ -1,12 +1,12 @@
-
 import os
 import unittest
 import warnings
 from pathlib import Path
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestCenterColumnStudyReactor(unittest.TestCase):
     """Test functionality of the CenterColumnStudyReactor class"""
@@ -26,7 +26,7 @@ def setUp(self):
             triangularity=0.45,
             plasma_gap_vertical_thickness=40,
             center_column_arc_vertical_thickness=520,
-            rotation_angle=359
+            rotation_angle=359,
         )
 
     def test_input_variable_names(self):
@@ -64,10 +64,12 @@ def test_rotation_angle_impacts_volume(self):
 
         self.test_reactor.rotation_angle = 90
         r90_comp_vols = [
-            comp.volume() for comp in self.test_reactor.shapes_and_components]
+            comp.volume() for comp in self.test_reactor.shapes_and_components
+        ]
         self.test_reactor.rotation_angle = 180
         r180_comp_vols = [
-            comp.volume() for comp in self.test_reactor.shapes_and_components]
+            comp.volume() for comp in self.test_reactor.shapes_and_components
+        ]
         for r90_vol, r180_vol in zip(r90_comp_vols, r180_comp_vols):
             assert r90_vol == pytest.approx(r180_vol * 0.5, rel=0.1)
 
@@ -87,23 +89,25 @@ def warning_trigger():
             warning_trigger()
             assert len(w) == 1
             assert issubclass(w[-1].category, UserWarning)
-            assert "360 degree rotation may result in a Standard_ConstructionError or AttributeError" in str(
-                w[-1].message)
+            assert (
+                "360 degree rotation may result in a Standard_ConstructionError or AttributeError"
+                in str(w[-1].message)
+            )
 
     def test_html_file_creation(self):
         """Creates a reactor with exports the step files and check they exist"""
 
-        os.system('rm *.html')
-        self.test_reactor.export_html_3d('cylinder.html')
-        assert Path('cylinder.html').is_file()
+        os.system("rm *.html")
+        self.test_reactor.export_html_3d("cylinder.html")
+        assert Path("cylinder.html").is_file()
 
     def test_export_brep(self):
         """Exports a brep file and checks that the output exist"""
 
         os.system("rm test_reactor.brep")
 
-        self.test_reactor.export_brep(filename='merged.brep', merge=True)
-        self.test_reactor.export_brep(filename='not_merged.brep', merge=False)
+        self.test_reactor.export_brep(filename="merged.brep", merge=True)
+        self.test_reactor.export_brep(filename="not_merged.brep", merge=False)
 
         assert Path("merged.brep").exists() is True
         assert Path("not_merged.brep").exists() is True
@@ -120,9 +124,6 @@ def test_export_brep_without_extention(self):
 
         def missing_extention():
 
-            self.test_reactor.export_brep(filename='test_reactor_missing')
+            self.test_reactor.export_brep(filename="test_reactor_missing")
 
-        self.assertRaises(
-            ValueError,
-            missing_extention
-        )
+        self.assertRaises(ValueError, missing_extention)
diff --git a/tests/test_parametric_reactors/test_eu_demo_2015_reactor.py b/tests/test_parametric_reactors/test_eu_demo_2015_reactor.py
index 748b84367..4d988a6bc 100644
--- a/tests/test_parametric_reactors/test_eu_demo_2015_reactor.py
+++ b/tests/test_parametric_reactors/test_eu_demo_2015_reactor.py
@@ -1,4 +1,3 @@
-
 import os
 import unittest
 from pathlib import Path
@@ -47,17 +46,17 @@ def test_make_demo_2015_reactor(self):
         files checking that each component results in a stp file"""
 
         output_filenames = [
-            'blanket.stp',
-            'divertor.stp',
-            'outboard_pf_coils.stp',
-            'pf_coils_1.stp',
-            'pf_coils_2.stp',
-            'pf_coils_3.stp',
-            'pf_coils_4.stp',
-            'pf_coils_5.stp',
-            'tf_coil_casing.stp',
-            'vacvessel.stp',
-            'another.stp'
+            "blanket.stp",
+            "divertor.stp",
+            "outboard_pf_coils.stp",
+            "pf_coils_1.stp",
+            "pf_coils_2.stp",
+            "pf_coils_3.stp",
+            "pf_coils_4.stp",
+            "pf_coils_5.stp",
+            "tf_coil_casing.stp",
+            "vacvessel.stp",
+            "another.stp",
         ]
         os.system("rm *.stp")
         my_reactor = paramak.EuDemoFrom2015PaperDiagram(number_of_tf_coils=1)
@@ -72,21 +71,22 @@ def test_make_parametric_demo_2015_rector(self):
         results in a stp file"""
 
         output_filenames = [
-            'blanket.stp',
-            'divertor.stp',
-            'outboard_pf_coils.stp',
-            'pf_coils_1.stp',
-            'pf_coils_2.stp',
-            'pf_coils_3.stp',
-            'pf_coils_4.stp',
-            'pf_coils_5.stp',
-            'tf_coil_casing.stp',
-            'vacvessel.stp',
-            'another.stp'
+            "blanket.stp",
+            "divertor.stp",
+            "outboard_pf_coils.stp",
+            "pf_coils_1.stp",
+            "pf_coils_2.stp",
+            "pf_coils_3.stp",
+            "pf_coils_4.stp",
+            "pf_coils_5.stp",
+            "tf_coil_casing.stp",
+            "vacvessel.stp",
+            "another.stp",
         ]
         os.system("rm *.stp")
         my_reactor = paramak.EuDemoFrom2015PaperDiagram(
-            number_of_tf_coils=1, rotation_angle=90)
+            number_of_tf_coils=1, rotation_angle=90
+        )
         my_reactor.export_stp(filename=output_filenames)
         for output_filename in output_filenames:
             assert Path(output_filename).exists() is True
diff --git a/tests/test_parametric_reactors/test_flf_system_code_reactor.py b/tests/test_parametric_reactors/test_flf_system_code_reactor.py
index 2b02c7f72..f7fb44c13 100644
--- a/tests/test_parametric_reactors/test_flf_system_code_reactor.py
+++ b/tests/test_parametric_reactors/test_flf_system_code_reactor.py
@@ -1,10 +1,12 @@
+import math
 import os
 import unittest
 from pathlib import Path
-import math
-import paramak
+
 import pytest
 
+import paramak
+
 
 class TestFlfSystemCodeReactor(unittest.TestCase):
     """Tests the FlfSystemCodeReactor functionality"""
@@ -32,45 +34,54 @@ def test_input_variable_names(self):
     def test_stp_file_creation(self):
         """Exports a step file and checks that it was saved successfully"""
 
-        os.system('rm *.stp')
-        self.test_reactor.export_stp(filename='cylinder.stp')
-        assert Path('cylinder.stp').is_file()
+        os.system("rm *.stp")
+        self.test_reactor.export_stp(filename="cylinder.stp")
+        assert Path("cylinder.stp").is_file()
 
     def test_multiple_stp_file_creation(self):
         """Exports the reactor as separate step files and checks
         that they are saved successfully"""
 
-        os.system('rm *.stp')
+        os.system("rm *.stp")
         self.test_reactor.export_stp()
-        assert Path('lower_vacuum_vessel.stp').is_file()
-        assert Path('lower_blanket.stp').is_file()
-        assert Path('blanket.stp').is_file()
-        assert Path('upper_blanket.stp').is_file()
-        assert Path('upper_vacuum_vessel.stp').is_file()
-        assert Path('vacuum_vessel.stp').is_file()
+        assert Path("lower_vacuum_vessel.stp").is_file()
+        assert Path("lower_blanket.stp").is_file()
+        assert Path("blanket.stp").is_file()
+        assert Path("upper_blanket.stp").is_file()
+        assert Path("upper_vacuum_vessel.stp").is_file()
+        assert Path("vacuum_vessel.stp").is_file()
 
     def test_order_of_names_in_reactor(self):
         """tests the order of Shapes in the reactor is as expected"""
 
         assert self.test_reactor.name == [
-            'blanket',
-            'vacuum_vessel',
-            'upper_blanket',
-            'lower_blanket',
-            'lower_vacuum_vessel',
-            'upper_vacuum_vessel',
+            "blanket",
+            "vacuum_vessel",
+            "upper_blanket",
+            "lower_blanket",
+            "lower_vacuum_vessel",
+            "upper_vacuum_vessel",
         ]
 
     def test_blanket_volume_against_analytical_volume(self):
         """Checks the volume of the blanket is approximately equal
         to the analytical volume of the half cylinder"""
 
-        outer_volume = math.pi * math.pow(
-            self.test_reactor.inner_blanket_radius + self.test_reactor.blanket_thickness,
-            2) * self.test_reactor.blanket_height
-        inner_volume = math.pi * \
-            math.pow(self.test_reactor.inner_blanket_radius, 2) * self.test_reactor.blanket_height
-        sector_fraction = 360. / self.test_reactor.rotation_angle
+        outer_volume = (
+            math.pi
+            * math.pow(
+                self.test_reactor.inner_blanket_radius
+                + self.test_reactor.blanket_thickness,
+                2,
+            )
+            * self.test_reactor.blanket_height
+        )
+        inner_volume = (
+            math.pi
+            * math.pow(self.test_reactor.inner_blanket_radius, 2)
+            * self.test_reactor.blanket_height
+        )
+        sector_fraction = 360.0 / self.test_reactor.rotation_angle
         blanket_volume = (outer_volume - inner_volume) / sector_fraction
 
         assert pytest.approx(self.test_reactor.volume()[0]) == blanket_volume
@@ -79,10 +90,17 @@ def test_upper_blanket_volume_against_analytical_volume(self):
         """Checks the volume of the upper_blanket is approximately equal
         to the analytical volume of the half cylinder"""
 
-        full_rotation_volume = math.pi * math.pow(
-            self.test_reactor.inner_blanket_radius + self.test_reactor.blanket_thickness + self.test_reactor.blanket_vv_gap,
-            2) * self.test_reactor.upper_blanket_thickness
-        sector_fraction = 360. / self.test_reactor.rotation_angle
+        full_rotation_volume = (
+            math.pi
+            * math.pow(
+                self.test_reactor.inner_blanket_radius
+                + self.test_reactor.blanket_thickness
+                + self.test_reactor.blanket_vv_gap,
+                2,
+            )
+            * self.test_reactor.upper_blanket_thickness
+        )
+        sector_fraction = 360.0 / self.test_reactor.rotation_angle
         blanket_volume = full_rotation_volume / sector_fraction
 
         assert pytest.approx(self.test_reactor.volume()[2]) == blanket_volume
diff --git a/tests/test_parametric_reactors/test_iter_reactor.py b/tests/test_parametric_reactors/test_iter_reactor.py
index 3401b7f0e..d3ce8f389 100644
--- a/tests/test_parametric_reactors/test_iter_reactor.py
+++ b/tests/test_parametric_reactors/test_iter_reactor.py
@@ -1,4 +1,3 @@
-
 import os
 import unittest
 from pathlib import Path
@@ -48,18 +47,18 @@ def test_make_demo_2015_reactor(self):
         files checking that each component results in a stp file"""
 
         output_filenames = [
-            'blanket.stp',
-            'divertor.stp',
-            'outboard_pf_coils.stp',
-            'pf_coils_1.stp',
-            'pf_coils_2.stp',
-            'pf_coils_3.stp',
-            'pf_coils_4.stp',
-            'pf_coils_5.stp',
-            'pf_coils_6.stp',
-            'tf_coils.stp',
-            'vacvessel.stp',
-            'another.stp',
+            "blanket.stp",
+            "divertor.stp",
+            "outboard_pf_coils.stp",
+            "pf_coils_1.stp",
+            "pf_coils_2.stp",
+            "pf_coils_3.stp",
+            "pf_coils_4.stp",
+            "pf_coils_5.stp",
+            "pf_coils_6.stp",
+            "tf_coils.stp",
+            "vacvessel.stp",
+            "another.stp",
         ]
         os.system("rm *.stp")
         my_reactor = paramak.IterFrom2020PaperDiagram(number_of_tf_coils=1)
@@ -74,22 +73,23 @@ def test_make_parametric_demo_2015_rector(self):
         results in a stp file"""
 
         output_filenames = [
-            'blanket.stp',
-            'divertor.stp',
-            'outboard_pf_coils.stp',
-            'pf_coils_1.stp',
-            'pf_coils_2.stp',
-            'pf_coils_3.stp',
-            'pf_coils_4.stp',
-            'pf_coils_5.stp',
-            'pf_coils_6.stp',
-            'tf_coils.stp',
-            'vacvessel.stp',
-            'another.stp',
+            "blanket.stp",
+            "divertor.stp",
+            "outboard_pf_coils.stp",
+            "pf_coils_1.stp",
+            "pf_coils_2.stp",
+            "pf_coils_3.stp",
+            "pf_coils_4.stp",
+            "pf_coils_5.stp",
+            "pf_coils_6.stp",
+            "tf_coils.stp",
+            "vacvessel.stp",
+            "another.stp",
         ]
         os.system("rm *.stp")
         my_reactor = paramak.IterFrom2020PaperDiagram(
-            number_of_tf_coils=1, rotation_angle=90)
+            number_of_tf_coils=1, rotation_angle=90
+        )
         my_reactor.export_stp(filename=output_filenames)
         for output_filename in output_filenames:
             assert Path(output_filename).exists() is True
diff --git a/tests/test_parametric_reactors/test_segmented_blanket_ball_reactor.py b/tests/test_parametric_reactors/test_segmented_blanket_ball_reactor.py
index debc436ad..8c7eda029 100644
--- a/tests/test_parametric_reactors/test_segmented_blanket_ball_reactor.py
+++ b/tests/test_parametric_reactors/test_segmented_blanket_ball_reactor.py
@@ -1,4 +1,3 @@
-
 import unittest
 
 import paramak
diff --git a/tests/test_parametric_reactors/test_single_null_ball_reactor.py b/tests/test_parametric_reactors/test_single_null_ball_reactor.py
index c842dadeb..405f8dc3e 100644
--- a/tests/test_parametric_reactors/test_single_null_ball_reactor.py
+++ b/tests/test_parametric_reactors/test_single_null_ball_reactor.py
@@ -1,9 +1,9 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestSingleNullBallReactor(unittest.TestCase):
     """tests functionality of the test_SingleNullBallReactor class"""
@@ -57,8 +57,7 @@ def test_single_null_ball_reactor_rotation_angle_impacts_volume(self):
         self.test_reactor.rotation_angle = 180
         test_reactor_180_components = self.test_reactor.shapes_and_components
 
-        for r90, r180 in zip(test_reactor_90_components,
-                             test_reactor_180_components):
+        for r90, r180 in zip(test_reactor_90_components, test_reactor_180_components):
             assert r90.volume() == pytest.approx(r180.volume() * 0.5, rel=0.1)
 
     def test_hash_value(self):
@@ -83,7 +82,7 @@ def test_hash_value(self):
             "_blanket_rear_wall",
             "_pf_coil",
             "_pf_coils_casing",
-            "_tf_coil"
+            "_tf_coil",
         ]:
             assert key not in self.test_reactor.__dict__.keys()
         assert self.test_reactor.shapes_and_components is not None
@@ -98,7 +97,7 @@ def test_hash_value(self):
             "_blanket_rear_wall",
             "_pf_coil",
             "_pf_coils_casing",
-            "_tf_coil"
+            "_tf_coil",
         ]:
             assert key in self.test_reactor.__dict__.keys()
         assert len(self.test_reactor.shapes_and_components) == 10
diff --git a/tests/test_parametric_reactors/test_single_null_submersion_tokamak.py b/tests/test_parametric_reactors/test_single_null_submersion_tokamak.py
index d88141b46..1a13f3d84 100644
--- a/tests/test_parametric_reactors/test_single_null_submersion_tokamak.py
+++ b/tests/test_parametric_reactors/test_single_null_submersion_tokamak.py
@@ -1,9 +1,9 @@
-
 import unittest
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestSingleNullSubmersionTokamak(unittest.TestCase):
     """Tests functionality of SingleNullSubmersionTokamak class"""
@@ -34,7 +34,7 @@ def setUp(self):
             rear_blanket_to_tf_gap=50,
             outboard_tf_coil_radial_thickness=30,
             outboard_tf_coil_poloidal_thickness=30,
-            divertor_position="lower"
+            divertor_position="lower",
         )
 
     def test_input_variable_names(self):
@@ -58,17 +58,18 @@ def test_single_null_submersion_tokamak_with_pf_and_tf_coils(self):
 
         assert len(self.test_reactor.shapes_and_components) == 11
 
-    def test_single_null_submersion_tokamak_rotation_angle_impacts_volume(
-            self):
+    def test_single_null_submersion_tokamak_rotation_angle_impacts_volume(self):
         """Creates SingleNullSubmersionTokamaks with different rotation angles and
         checks that the relative volumes of the components are correct."""
 
         self.test_reactor.rotation_angle = 90
         comps_90_vol = [
-            comp.volume() for comp in self.test_reactor.shapes_and_components]
+            comp.volume() for comp in self.test_reactor.shapes_and_components
+        ]
         self.test_reactor.rotation_angle = 180
         comps_180_vol = [
-            comp.volume() for comp in self.test_reactor.shapes_and_components]
+            comp.volume() for comp in self.test_reactor.shapes_and_components
+        ]
 
         for vol_90, vol_180 in zip(comps_90_vol, comps_180_vol):
             assert vol_90 == pytest.approx(vol_180 * 0.5, rel=0.1)
@@ -109,7 +110,7 @@ def test_hash_value(self):
             "_outboard_rear_blanket_wall",
             "_tf_coil",
             "_pf_coil",
-            "_pf_coils_casing"
+            "_pf_coils_casing",
         ]:
             assert key not in self.test_reactor.__dict__.keys()
         assert self.test_reactor.shapes_and_components is not None
@@ -129,7 +130,7 @@ def test_hash_value(self):
             "_outboard_rear_blanket_wall",
             "_tf_coil",
             "_pf_coil",
-            "_pf_coils_casing"
+            "_pf_coils_casing",
         ]:
             assert key in self.test_reactor.__dict__.keys()
         assert len(self.test_reactor.shapes_and_components) == 11
diff --git a/tests/test_parametric_reactors/test_sparc_2020_reactor.py b/tests/test_parametric_reactors/test_sparc_2020_reactor.py
index 4503b5151..55587117c 100644
--- a/tests/test_parametric_reactors/test_sparc_2020_reactor.py
+++ b/tests/test_parametric_reactors/test_sparc_2020_reactor.py
@@ -1,4 +1,3 @@
-
 import os
 import unittest
 from pathlib import Path
@@ -7,7 +6,7 @@
 
 
 class TestSparc2020Reactor(unittest.TestCase):
-    """"Tests functionality of the Sparc2020Reactor class"""
+    """ "Tests functionality of the Sparc2020Reactor class"""
 
     def setUp(self):
         self.test_reactor = paramak.BallReactor(
diff --git a/tests/test_parametric_reactors/test_submersion_tokamak.py b/tests/test_parametric_reactors/test_submersion_tokamak.py
index 3b053986b..28d3f0c7b 100644
--- a/tests/test_parametric_reactors/test_submersion_tokamak.py
+++ b/tests/test_parametric_reactors/test_submersion_tokamak.py
@@ -1,11 +1,11 @@
-
 import os
 import unittest
 from pathlib import Path
 
-import paramak
 import pytest
 
+import paramak
+
 
 class TestSubmersionTokamak(unittest.TestCase):
     """Tests functionality of the SubmersionTokamak class"""
@@ -164,7 +164,7 @@ def test_with_tf_and_pf_coils_stp_creation(self):
             "tf_pf_SubmersionTokamak/outboard_rear_blanket_wall.stp",
             "tf_pf_SubmersionTokamak/pf_coil_cases.stp",
             "tf_pf_SubmersionTokamak/another1.stp",
-            "tf_pf_SubmersionTokamak/another2.stp"
+            "tf_pf_SubmersionTokamak/another2.stp",
         ]
         self.test_reactor.export_stp(filename=output_filenames)
 
@@ -182,8 +182,11 @@ def warning_trigger():
                 self.test_reactor._rotation_angle_check()
             except BaseException:
                 pass
-        msg = "360 degree rotation may result in a " + \
-            "Standard_ConstructionError or AttributeError"
+
+        msg = (
+            "360 degree rotation may result in a "
+            + "Standard_ConstructionError or AttributeError"
+        )
         with pytest.warns(UserWarning, match=msg):
             warning_trigger()
 
@@ -222,7 +225,7 @@ def test_submersion_reactor_hash_value(self):
             "_outboard_rear_blanket_wall",
             "_tf_coil",
             "_pf_coil",
-            "_pf_coils_casing"
+            "_pf_coils_casing",
         ]:
             assert key not in self.test_reactor.__dict__
 
@@ -242,7 +245,7 @@ def test_submersion_reactor_hash_value(self):
             "_outboard_rear_blanket_wall",
             "_tf_coil",
             "_pf_coil",
-            "_pf_coils_casing"
+            "_pf_coils_casing",
         ]:
             assert key in self.test_reactor.__dict__.keys()
 
diff --git a/tests/test_parametric_shapes/test_extrude_circle_shape.py b/tests/test_parametric_shapes/test_extrude_circle_shape.py
index b77bb6ab9..245d8da9b 100644
--- a/tests/test_parametric_shapes/test_extrude_circle_shape.py
+++ b/tests/test_parametric_shapes/test_extrude_circle_shape.py
@@ -4,15 +4,13 @@
 from pathlib import Path
 
 import pytest
+
 from paramak import ExtrudeCircleShape
 
 
 class TestExtrudeCircleShape(unittest.TestCase):
-
     def setUp(self):
-        self.test_shape = ExtrudeCircleShape(
-            points=[(30, 0)], radius=10, distance=30
-        )
+        self.test_shape = ExtrudeCircleShape(points=[(30, 0)], radius=10, distance=30)
 
     def test_default_parameters(self):
         """Checks that the default parameters of an ExtrudeCircleShape are correct."""
@@ -24,7 +22,7 @@ def test_absolute_shape_volume(self):
         """Creates an ExtrudeCircleShape and checks that its volume is correct."""
 
         assert self.test_shape.solid is not None
-        assert self.test_shape.volume() == pytest.approx(math.pi * (10**2) * 30)
+        assert self.test_shape.volume() == pytest.approx(math.pi * (10 ** 2) * 30)
 
     def test_relative_shape_volume(self):
         """Creates two ExtrudeCircleShapes and checks that their relative
@@ -39,40 +37,38 @@ def test_absolute_shape_areas(self):
         are correct."""
 
         assert self.test_shape.area == pytest.approx(
-            (math.pi * (10**2) * 2) + (math.pi * (2 * 10) * 30)
+            (math.pi * (10 ** 2) * 2) + (math.pi * (2 * 10) * 30)
         )
         assert len(self.test_shape.areas) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (2 * 10) * 30)) == 1
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2))) == 2
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (2 * 10) * 30)) == 1
 
     def test_cut_volume(self):
         """Creates an ExtrudeCircleShape with another ExtrudeCircleShape cut out
         and checks that the volume is correct."""
 
         shape_with_cut = ExtrudeCircleShape(
-            points=[(30, 0)], radius=20, distance=40,
-            cut=self.test_shape
+            points=[(30, 0)], radius=20, distance=40, cut=self.test_shape
         )
 
         assert shape_with_cut.volume() == pytest.approx(
-            (math.pi * (20**2) * 40) - (math.pi * (10**2) * 30)
+            (math.pi * (20 ** 2) * 40) - (math.pi * (10 ** 2) * 30)
         )
 
     def test_intersect_volume(self):
         """Creates ExtrudeCircleShapes with other ExtrudeCircleShapes
         intersected and checks that their volumes are correct."""
 
-        intersect_shape = ExtrudeCircleShape(
-            points=[(30, 0)], radius=5, distance=50)
+        intersect_shape = ExtrudeCircleShape(points=[(30, 0)], radius=5, distance=50)
 
         intersected_shape = ExtrudeCircleShape(
-            points=[(30, 0)], radius=10, distance=50,
-            intersect=[self.test_shape, intersect_shape]
+            points=[(30, 0)],
+            radius=10,
+            distance=50,
+            intersect=[self.test_shape, intersect_shape],
         )
 
-        assert intersected_shape.volume() == pytest.approx(math.pi * 5**2 * 30)
+        assert intersected_shape.volume() == pytest.approx(math.pi * 5 ** 2 * 30)
 
     def test_rotation_angle(self):
         """Creates an ExtrudeCircleShape with a rotation_angle < 360 and checks
@@ -89,8 +85,7 @@ def test_extrude_both(self):
 
         test_volume_extrude_both = self.test_shape.volume()
         self.test_shape.extrude_both = False
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume_extrude_both)
+        assert self.test_shape.volume() == pytest.approx(test_volume_extrude_both)
 
     def test_export_stp(self):
         """Exports and stp file with mode = solid and wire and checks
@@ -98,18 +93,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
diff --git a/tests/test_parametric_shapes/test_extrude_mixed_shape.py b/tests/test_parametric_shapes/test_extrude_mixed_shape.py
index 27895cad9..7ac61d34c 100644
--- a/tests/test_parametric_shapes/test_extrude_mixed_shape.py
+++ b/tests/test_parametric_shapes/test_extrude_mixed_shape.py
@@ -1,14 +1,13 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import ExtrudeMixedShape
 
 
 class TestExtrudeMixedShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = ExtrudeMixedShape(
             points=[
@@ -17,9 +16,9 @@ def setUp(self):
                 (60, 70, "spline"),
                 (70, 50, "circle"),
                 (60, 25, "circle"),
-                (70, 0, "straight")
+                (70, 0, "straight"),
             ],
-            distance=50
+            distance=50,
         )
 
         self.test_shape_2 = ExtrudeMixedShape(
@@ -32,7 +31,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "straight"),
                 (110, 45, "straight"),
-            ]
+            ],
         )
 
         self.test_shape_3 = ExtrudeMixedShape(
@@ -45,7 +44,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "circle"),
                 (110, 45, "circle"),
-            ]
+            ],
         )
 
     def test_default_parameters(self):
@@ -68,8 +67,7 @@ def test_relative_shape_volume(self):
         test_volume = self.test_shape.volume()
         self.test_shape.azimuth_placement_angle = [0, 180]
 
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 2, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 2, rel=0.01)
 
     def test_shape_face_areas(self):
         """Creates an ExtrudeMixedShape and checks that the face areas are
@@ -145,8 +143,7 @@ def test_rotation_angle(self):
         self.test_shape.azimuth_placement_angle = [45, 135, 225, 315]
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
     def test_extrude_both(self):
         """Creates an ExtrudeMixedShape with extrude_both = True and False and
@@ -154,8 +151,7 @@ def test_extrude_both(self):
 
         test_volume_extrude_both = self.test_shape.volume()
         self.test_shape.extrude_both = False
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume_extrude_both)
+        assert self.test_shape.volume() == pytest.approx(test_volume_extrude_both)
 
     def test_export_stp(self):
         """Exports and stp file with mode = solid and wire and checks
@@ -163,18 +159,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert pytest.approx(Path("test_solid.stp").stat().st_size, rel=1) == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            pytest.approx(Path("test_solid.stp").stat().st_size, rel=1)
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -187,7 +187,7 @@ def test_convert_all_circle_points_change_to_splines(self):
         self.test_shape_2.convert_all_circle_connections_to_splines()
         assert len(self.test_shape_2.processed_points) > 8
         assert self.test_shape_2.processed_points[0] == (100, 0, "straight")
-        assert self.test_shape_2.processed_points[1] == (200, 0, 'spline')
+        assert self.test_shape_2.processed_points[1] == (200, 0, "spline")
 
         # last point is the same as the first point
         assert self.test_shape_2.processed_points[-1] == (100, 0, "straight")
@@ -196,9 +196,10 @@ def test_convert_all_circle_points_change_to_splines(self):
         assert self.test_shape_2.processed_points[-4] == (150, 100, "straight")
         assert self.test_shape_2.processed_points[-5] == (200, 100, "straight")
 
-        for point in self.test_shape_2.processed_points[1:len(
-                self.test_shape_2.points) - 5]:
-            assert point[2] == 'spline'
+        for point in self.test_shape_2.processed_points[
+            1 : len(self.test_shape_2.points) - 5
+        ]:
+            assert point[2] == "spline"
 
     def test_convert_circles_to_splines_volume(self):
         """creates a RotateMixedShape with a circular edge and converts the
diff --git a/tests/test_parametric_shapes/test_extrude_spline_shape.py b/tests/test_parametric_shapes/test_extrude_spline_shape.py
index 286088ea6..9cfa6afae 100644
--- a/tests/test_parametric_shapes/test_extrude_spline_shape.py
+++ b/tests/test_parametric_shapes/test_extrude_spline_shape.py
@@ -1,18 +1,26 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import ExtrudeSplineShape
 
 
 class TestExtrudeSplineShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = ExtrudeSplineShape(
-            points=[(50, 0), (50, 20), (70, 80), (90, 50), (70, 0), (90, -50),
-                    (70, -80), (50, -20)], distance=30
+            points=[
+                (50, 0),
+                (50, 20),
+                (70, 80),
+                (90, 50),
+                (70, 0),
+                (90, -50),
+                (70, -80),
+                (50, -20),
+            ],
+            distance=30,
         )
 
     def test_default_parameters(self):
@@ -44,8 +52,7 @@ def test_relative_shape_volume(self):
         test_volume = self.test_shape.volume()
         self.test_shape.azimuth_placement_angle = [0, 180]
 
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 2, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 2, rel=0.01)
 
     def test_cut_volume(self):
         """Creates an ExtrudeSplineShape with another ExtrudeSplineShape cut out
@@ -60,7 +67,8 @@ def test_cut_volume(self):
         )
 
         outer_shape_with_cut = ExtrudeSplineShape(
-            points=[(3, 3), (3, 12), (12, 12), (12, 3)], cut=inner_shape,
+            points=[(3, 3), (3, 12), (12, 12), (12, 3)],
+            cut=inner_shape,
             distance=30,
         )
 
@@ -75,8 +83,7 @@ def test_rotation_angle(self):
         self.test_shape.azimuth_placement_angle = [45, 135, 225, 315]
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
     def test_extrude_both(self):
         """Creates an ExtrudeSplineShape with extrude_both = True and False and
@@ -84,8 +91,7 @@ def test_extrude_both(self):
 
         test_volume_extrude_both = self.test_shape.volume()
         self.test_shape.extrude_both = False
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume_extrude_both)
+        assert self.test_shape.volume() == pytest.approx(test_volume_extrude_both)
 
     def test_export_stp(self):
         """Exports and stp file with mode = solid and wire and checks that the
@@ -93,18 +99,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -114,16 +124,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'spline'),
-                (10, 30, 'spline'),
-                (30, 30, 'spline'),
-                (30, 10, 'spline')
+                (10, 10, "spline"),
+                (10, 30, "spline"),
+                (30, 30, "spline"),
+                (30, 10, "spline"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_parametric_shapes/test_extrude_straight_shape.py b/tests/test_parametric_shapes/test_extrude_straight_shape.py
index c83f00767..8761567d5 100644
--- a/tests/test_parametric_shapes/test_extrude_straight_shape.py
+++ b/tests/test_parametric_shapes/test_extrude_straight_shape.py
@@ -1,15 +1,14 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
 from cadquery import Plane
+
 from paramak import ExtrudeStraightShape
 
 
 class TestExtrudeStraightShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = ExtrudeStraightShape(
             points=[(10, 10), (10, 30), (30, 30), (30, 10)], distance=30
@@ -25,8 +24,9 @@ def test_workplane_of_type_cadquery_plane(self):
 
         test_shape_2 = ExtrudeStraightShape(
             workplane=workplane,
-            rotation_axis='X',
-            points=[(10, 10), (10, 30), (30, 30), (30, 10)], distance=30
+            rotation_axis="X",
+            points=[(10, 10), (10, 30), (30, 30), (30, 10)],
+            distance=30,
         )
 
         assert isinstance(test_shape_2.workplane, Plane)
@@ -50,9 +50,7 @@ def test_absolute_shape_areas(self):
         """Creates an ExtrudeStraightShape and checks that the volume is
         correct."""
 
-        assert self.test_shape.area == pytest.approx(
-            (20 * 20 * 2) + (20 * 30 * 4)
-        )
+        assert self.test_shape.area == pytest.approx((20 * 20 * 2) + (20 * 30 * 4))
         assert len(self.test_shape.areas) == 6
         assert self.test_shape.areas.count(pytest.approx(20 * 20)) == 2
         assert self.test_shape.areas.count(pytest.approx(20 * 30)) == 4
@@ -71,21 +69,21 @@ def test_cut_volume(self):
         out and checks that the volume is correct."""
 
         shape_with_cut = ExtrudeStraightShape(
-            points=[(0, 0), (0, 40), (40, 40), (40, 0)], distance=40,
-            cut=self.test_shape
+            points=[(0, 0), (0, 40), (40, 40), (40, 0)],
+            distance=40,
+            cut=self.test_shape,
         )
 
-        assert shape_with_cut.volume() == pytest.approx(
-            (40 * 40 * 40) - (20 * 20 * 30)
-        )
+        assert shape_with_cut.volume() == pytest.approx((40 * 40 * 40) - (20 * 20 * 30))
 
     def test_union_volume(self):
         """Creates a union of two ExtrudeStraightShapes and checks that the
         volume is correct."""
 
         unioned_shape = ExtrudeStraightShape(
-            points=[(0, 10), (0, 30), (20, 30), (20, 10)], distance=30,
-            union=self.test_shape
+            points=[(0, 10), (0, 30), (20, 30), (20, 10)],
+            distance=30,
+            union=self.test_shape,
         )
         assert unioned_shape.volume() == pytest.approx(30 * 20 * 30)
 
@@ -94,8 +92,9 @@ def test_intersect_volume(self):
         intersected and checks that the volume is correct."""
 
         intersected_shape = ExtrudeStraightShape(
-            points=[(0, 10), (0, 30), (20, 30), (20, 10)], distance=30,
-            intersect=self.test_shape
+            points=[(0, 10), (0, 30), (20, 30), (20, 10)],
+            distance=30,
+            intersect=self.test_shape,
         )
         assert intersected_shape.volume() == pytest.approx(10 * 20 * 30)
 
@@ -107,8 +106,7 @@ def test_rotation_angle(self):
         self.rotation_axis = "Y"
         test_volume = self.test_shape.volume()
         self.test_shape.rotation_angle = 180
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.5, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.5, rel=0.01)
 
     def test_extrude_both(self):
         """Creates an ExtrudeStraightShape with extrude_both = True and False
@@ -116,8 +114,7 @@ def test_extrude_both(self):
 
         test_volume_extrude_both = self.test_shape.volume()
         self.test_shape.extrude_both = False
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume_extrude_both)
+        assert self.test_shape.volume() == pytest.approx(test_volume_extrude_both)
 
     def test_export_stp(self):
         """Exports and stp file with mode = solid and wire and checks that the
@@ -125,18 +122,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -146,16 +147,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'straight'),
-                (10, 30, 'straight'),
-                (30, 30, 'straight'),
-                (30, 10, 'straight')
+                (10, 10, "straight"),
+                (10, 30, "straight"),
+                (30, 30, "straight"),
+                (30, 10, "straight"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
     def test_export_html_with_different_workplanes(self):
         """Checks that all the workplanes produce an html file when using the
@@ -166,8 +164,8 @@ def test_export_html_with_different_workplanes(self):
             self.test_shape.workplane = workplane
             fig = self.test_shape.export_html(workplane + ".html")
             assert Path(workplane + ".html").exists() is True
-            assert fig.layout.xaxis.title['text'] == workplane[0]
-            assert fig.layout.yaxis.title['text'] == workplane[1]
+            assert fig.layout.xaxis.title["text"] == workplane[0]
+            assert fig.layout.yaxis.title["text"] == workplane[1]
 
 
 if __name__ == "__main__":
diff --git a/tests/test_parametric_shapes/test_rotate_circle_shape.py b/tests/test_parametric_shapes/test_rotate_circle_shape.py
index a826bae6b..3b11803ad 100644
--- a/tests/test_parametric_shapes/test_rotate_circle_shape.py
+++ b/tests/test_parametric_shapes/test_rotate_circle_shape.py
@@ -1,20 +1,16 @@
-
 import math
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateCircleShape
 
 
 class TestRotateCircleShape(unittest.TestCase):
-
     def setUp(self):
-        self.test_shape = RotateCircleShape(
-            points=[(60, 0)],
-            radius=10
-        )
+        self.test_shape = RotateCircleShape(points=[(60, 0)], radius=10)
 
     def test_default_parameters(self):
         """Checks that the default parameters of a RotateCircleShape are correct."""
@@ -31,7 +27,7 @@ def test_absolute_shape_volume(self):
         # )
         self.test_shape.rotation_angle = 270
         assert self.test_shape.volume() == pytest.approx(
-            2 * math.pi * 60 * math.pi * (10**2) * 0.75
+            2 * math.pi * 60 * math.pi * (10 ** 2) * 0.75
         )
 
     def test_absolute_shape_areas(self):
@@ -47,12 +43,17 @@ def test_absolute_shape_areas(self):
 
         self.test_shape.rotation_angle = 180
         assert self.test_shape.area == pytest.approx(
-            ((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * math.pi * (60 * 2) / 2), rel=0.01)
+            ((math.pi * (10 ** 2)) * 2) + (math.pi * (10 * 2) * math.pi * (60 * 2) / 2),
+            rel=0.01,
+        )
         assert len(self.test_shape.areas) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2))) == 2
-        assert self.test_shape.areas.count(pytest.approx(
-            math.pi * (10 * 2) * math.pi * (60 * 2) / 2, rel=0.01)) == 1
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2))) == 2
+        assert (
+            self.test_shape.areas.count(
+                pytest.approx(math.pi * (10 * 2) * math.pi * (60 * 2) / 2, rel=0.01)
+            )
+            == 1
+        )
 
     def test_relative_shape_volume_azimuth_placement_angle(self):
         """Creates two RotateCircleShapes with different
@@ -61,21 +62,19 @@ def test_relative_shape_volume_azimuth_placement_angle(self):
 
         self.test_shape.rotation_angle = 10
         assert self.test_shape.volume() == pytest.approx(
-            (math.pi * 10**2) * ((2 * math.pi * 60) / 36)
+            (math.pi * 10 ** 2) * ((2 * math.pi * 60) / 36)
         )
 
         self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]
         assert self.test_shape.volume() == pytest.approx(
-            (math.pi * 10**2) * ((2 * math.pi * 60) / 36) * 4
+            (math.pi * 10 ** 2) * ((2 * math.pi * 60) / 36) * 4
         )
 
     def test_cut_volume(self):
         """Creates a RotateCircleShape with another RotateCircleShape cut out
         and checks that the volume is correct."""
 
-        outer_shape = RotateCircleShape(
-            points=[(60, 0)], radius=15
-        )
+        outer_shape = RotateCircleShape(points=[(60, 0)], radius=15)
         outer_shape_volume = outer_shape.volume()
         outer_shape.cut = self.test_shape
         assert outer_shape.volume() == pytest.approx(
@@ -88,16 +87,18 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
         # the circle wire file is actually larger than the circle solid file
         # assert Path("test_wire.stp").stat().st_size < \
         #     Path("test_solid2.stp").stat().st_size
diff --git a/tests/test_parametric_shapes/test_rotate_mixed_shape.py b/tests/test_parametric_shapes/test_rotate_mixed_shape.py
index cdbc5a050..e4767af1d 100644
--- a/tests/test_parametric_shapes/test_rotate_mixed_shape.py
+++ b/tests/test_parametric_shapes/test_rotate_mixed_shape.py
@@ -1,18 +1,23 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateMixedShape
 
 
 class TestRotateMixedShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = RotateMixedShape(
-            points=[(50, 0, "straight"), (50, 50, "spline"), (60, 70, "spline"),
-                    (70, 50, "circle"), (60, 25, "circle"), (70, 0, "straight")]
+            points=[
+                (50, 0, "straight"),
+                (50, 50, "spline"),
+                (60, 70, "spline"),
+                (70, 50, "circle"),
+                (60, 25, "circle"),
+                (70, 0, "straight"),
+            ]
         )
 
         self.test_shape_2 = RotateMixedShape(
@@ -25,7 +30,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "straight"),
                 (110, 45, "straight"),
-            ]
+            ],
         )
 
         self.test_shape_3 = RotateMixedShape(
@@ -38,7 +43,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "circle"),
                 (110, 45, "circle"),
-            ]
+            ],
         )
 
     def test_export_2d_image(self):
@@ -167,7 +172,7 @@ def test_cut_volume(self):
                 (80, 80, "circle"),
                 (100, 40, "circle"),
                 (80, 0, "straight"),
-                (80, -10, "straight")
+                (80, -10, "straight"),
             ]
         )
         outer_shape_volume = outer_shape.volume()
@@ -218,18 +223,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -242,13 +251,13 @@ def test_convert_all_circle_points_change_to_splines(self):
         self.test_shape_3.convert_all_circle_connections_to_splines()
         assert len(self.test_shape_3.processed_points) > 8
         assert self.test_shape_3.processed_points[0] == (100, 0, "straight")
-        assert self.test_shape_3.processed_points[1][2] == 'spline'
-        assert self.test_shape_3.processed_points[2][2] == 'spline'
+        assert self.test_shape_3.processed_points[1][2] == "spline"
+        assert self.test_shape_3.processed_points[2][2] == "spline"
 
         # last point is the same as the first point
         assert self.test_shape_3.processed_points[-1] == (100, 0, "straight")
-        assert self.test_shape_3.processed_points[-2][2] == 'spline'
-        assert self.test_shape_3.processed_points[-3][2] == 'spline'
+        assert self.test_shape_3.processed_points[-2][2] == "spline"
+        assert self.test_shape_3.processed_points[-3][2] == "spline"
 
     def test_convert_circles_to_splines_volume(self):
         """creates a RotateMixedShape with a circular edge and converts the
diff --git a/tests/test_parametric_shapes/test_rotate_spline_shape.py b/tests/test_parametric_shapes/test_rotate_spline_shape.py
index 3c64e0fa6..e1a3e0210 100644
--- a/tests/test_parametric_shapes/test_rotate_spline_shape.py
+++ b/tests/test_parametric_shapes/test_rotate_spline_shape.py
@@ -1,18 +1,26 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateSplineShape
 
 
 class TestRotateSplineShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = RotateSplineShape(
-            points=[(50, 0), (50, 20), (70, 80), (90, 50), (70, 0),
-                    (90, -50), (70, -80), (50, -20)])
+            points=[
+                (50, 0),
+                (50, 20),
+                (70, 80),
+                (90, 50),
+                (70, 0),
+                (90, -50),
+                (70, -80),
+                (50, -20),
+            ]
+        )
 
     def test_default_parameters(self):
         """Checks that the default parameters of a RotateSplineShape are
@@ -55,8 +63,7 @@ def test_cut_volume(self):
 
         assert inner_shape.volume() == pytest.approx(900.88, abs=0.1)
         assert outer_shape.volume() == pytest.approx(2881.76, abs=0.1)
-        assert outer_shape_with_cut.volume() == pytest.approx(
-            2881.76 - 900.88, abs=0.2)
+        assert outer_shape_with_cut.volume() == pytest.approx(2881.76 - 900.88, abs=0.2)
 
     def test_shape_face_areas(self):
         """Creates RotateSplineShapes and checks that the face areas are
@@ -75,18 +82,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -96,16 +107,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'spline'),
-                (10, 30, 'spline'),
-                (30, 30, 'spline'),
-                (30, 10, 'spline')
+                (10, 10, "spline"),
+                (10, 30, "spline"),
+                (30, 30, "spline"),
+                (30, 10, "spline"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_parametric_shapes/test_rotate_straight_shape.py b/tests/test_parametric_shapes/test_rotate_straight_shape.py
index 28a42e987..5ffe75900 100644
--- a/tests/test_parametric_shapes/test_rotate_straight_shape.py
+++ b/tests/test_parametric_shapes/test_rotate_straight_shape.py
@@ -1,15 +1,14 @@
-
 import math
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateStraightShape
 
 
 class TestRotateStraightShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = RotateStraightShape(
             points=[(0, 0), (0, 20), (20, 20), (20, 0)]
@@ -37,7 +36,7 @@ def test_absolute_shape_volume(self):
         """Creates a RotateStraightShape and checks that its volume is correct."""
 
         assert self.test_shape.solid is not None
-        assert self.test_shape.volume() == pytest.approx(math.pi * (20**2) * 20)
+        assert self.test_shape.volume() == pytest.approx(math.pi * (20 ** 2) * 20)
 
     def test_relative_shape_volume(self):
         """Creates two RotateStraightShapes and checks that their relative volumes
@@ -73,48 +72,60 @@ def test_absolute_shape_areas(self):
         are correct."""
 
         assert self.test_shape.area == pytest.approx(
-            (math.pi * (20**2) * 2) + (math.pi * (20 * 2) * 20))
+            (math.pi * (20 ** 2) * 2) + (math.pi * (20 * 2) * 20)
+        )
         assert len(self.test_shape.areas) == 3
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (20**2))) == 2
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (20 * 2) * 20)) == 1
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (20 ** 2))) == 2
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (20 * 2) * 20)) == 1
 
         self.test_shape.rotation_angle = 180
         assert self.test_shape.area == pytest.approx(
-            ((math.pi * (20**2) / 2) * 2) + (20 * 40) + (math.pi * (20 * 2) * 20 / 2))
+            ((math.pi * (20 ** 2) / 2) * 2) + (20 * 40) + (math.pi * (20 * 2) * 20 / 2)
+        )
         assert len(self.test_shape.areas) == 4
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (20**2) / 2)) == 2
+        assert self.test_shape.areas.count(pytest.approx(math.pi * (20 ** 2) / 2)) == 2
         assert self.test_shape.areas.count(pytest.approx(20 * 40)) == 1
-        assert self.test_shape.areas.count(
-            pytest.approx((math.pi * (20 * 2) * 20) / 2)) == 1
+        assert (
+            self.test_shape.areas.count(pytest.approx((math.pi * (20 * 2) * 20) / 2))
+            == 1
+        )
 
         test_shape = RotateStraightShape(
             points=[(50, 0), (50, 50), (70, 50), (70, 0)],
         )
 
         assert test_shape.area == pytest.approx(
-            (((math.pi * (70**2)) - (math.pi * (50**2))) * 2) + (math.pi * (50 * 2) * 50) + (math.pi * (70 * 2) * 50))
+            (((math.pi * (70 ** 2)) - (math.pi * (50 ** 2))) * 2)
+            + (math.pi * (50 * 2) * 50)
+            + (math.pi * (70 * 2) * 50)
+        )
         assert len(test_shape.areas) == 4
-        assert test_shape.areas.count(pytest.approx(
-            (math.pi * (70**2)) - (math.pi * (50**2)))) == 2
-        assert test_shape.areas.count(
-            pytest.approx(math.pi * (50 * 2) * 50)) == 1
-        assert test_shape.areas.count(
-            pytest.approx(math.pi * (70 * 2) * 50)) == 1
+        assert (
+            test_shape.areas.count(
+                pytest.approx((math.pi * (70 ** 2)) - (math.pi * (50 ** 2)))
+            )
+            == 2
+        )
+        assert test_shape.areas.count(pytest.approx(math.pi * (50 * 2) * 50)) == 1
+        assert test_shape.areas.count(pytest.approx(math.pi * (70 * 2) * 50)) == 1
 
         test_shape.rotation_angle = 180
-        assert test_shape.area == pytest.approx((20 * 50 * 2) + ((((math.pi * (70**2)) / 2) - (
-            (math.pi * (50**2)) / 2)) * 2) + ((math.pi * (50 * 2) * 50) / 2) + ((math.pi * (70 * 2) * 50) / 2))
+        assert test_shape.area == pytest.approx(
+            (20 * 50 * 2)
+            + ((((math.pi * (70 ** 2)) / 2) - ((math.pi * (50 ** 2)) / 2)) * 2)
+            + ((math.pi * (50 * 2) * 50) / 2)
+            + ((math.pi * (70 * 2) * 50) / 2)
+        )
         assert len(test_shape.areas) == 6
         assert test_shape.areas.count(pytest.approx(20 * 50)) == 2
-        assert test_shape.areas.count(pytest.approx(
-            ((math.pi * (70**2)) / 2) - ((math.pi * (50**2)) / 2))) == 2
-        assert test_shape.areas.count(
-            pytest.approx(math.pi * (50 * 2) * 50 / 2)) == 1
-        assert test_shape.areas.count(
-            pytest.approx(math.pi * (70 * 2) * 50 / 2)) == 1
+        assert (
+            test_shape.areas.count(
+                pytest.approx(((math.pi * (70 ** 2)) / 2) - ((math.pi * (50 ** 2)) / 2))
+            )
+            == 2
+        )
+        assert test_shape.areas.count(pytest.approx(math.pi * (50 * 2) * 50 / 2)) == 1
+        assert test_shape.areas.count(pytest.approx(math.pi * (70 * 2) * 50 / 2)) == 1
 
     def test_export_stp_extension(self):
         """Creates a RotateStraightShape and checks that a stp file of the
@@ -134,12 +145,12 @@ def test_export_stp_extension_in_cm(self):
         method."""
 
         os.system("rm filename.stp filename.step")
-        self.test_shape.export_stp("filename.stp", units='cm')
-        self.test_shape.export_stp("filename.step", units='cm')
+        self.test_shape.export_stp("filename.stp", units="cm")
+        self.test_shape.export_stp("filename.step", units="cm")
         assert Path("filename.stp").exists() is True
         assert Path("filename.step").exists() is True
         os.system("rm filename.stp filename.step")
-        self.test_shape.export_stp("filename_cm.stp", units='cm')
+        self.test_shape.export_stp("filename_cm.stp", units="cm")
         assert Path("filename_cm.stp").exists() is True
         os.system("rm filename_cm.stp")
 
@@ -181,8 +192,7 @@ def test_export_svg_options(self):
         assert Path("marginTop.svg").exists() is True
         self.test_shape.export_svg("showAxes.svg", showAxes=True)
         assert Path("showAxes.svg").exists() is True
-        self.test_shape.export_svg(
-            "projectionDir.svg", projectionDir=(-1, -1, -1))
+        self.test_shape.export_svg("projectionDir.svg", projectionDir=(-1, -1, -1))
         assert Path("projectionDir.svg").exists() is True
         self.test_shape.export_svg("strokeColor.svg", strokeColor=(42, 42, 42))
         assert Path("strokeColor.svg").exists() is True
@@ -200,12 +210,11 @@ def test_cut_volume(self):
         cut out and checks that the volume is correct."""
 
         shape_with_cut = RotateStraightShape(
-            points=[(0, -5), (0, 25), (25, 25), (25, -5)],
-            cut=self.test_shape
+            points=[(0, -5), (0, 25), (25, 25), (25, -5)], cut=self.test_shape
         )
 
         assert shape_with_cut.volume() == pytest.approx(
-            (math.pi * (25**2) * 30) - (math.pi * (20**2) * 20)
+            (math.pi * (25 ** 2) * 30) - (math.pi * (20 ** 2) * 20)
         )
 
     def test_multiple_cut_volume(self):
@@ -226,13 +235,13 @@ def test_multiple_cut_volume(self):
 
         main_shape_with_cuts = RotateStraightShape(
             points=[(0, 0), (0, 200), (200, 200), (200, 0)],
-            cut=[shape_to_cut_1, shape_to_cut_2]
+            cut=[shape_to_cut_1, shape_to_cut_2],
         )
 
         assert main_shape_with_cuts.volume() == pytest.approx(
-            (math.pi * (200**2) * 200) -
-            ((math.pi * (40**2) * 200) - (math.pi * (20**2) * 200)) -
-            ((math.pi * (140**2) * 200) - (math.pi * (120**2) * 200))
+            (math.pi * (200 ** 2) * 200)
+            - ((math.pi * (40 ** 2) * 200) - (math.pi * (20 ** 2) * 200))
+            - ((math.pi * (140 ** 2) * 200) - (math.pi * (120 ** 2) * 200))
         )
 
     def test_hash_value(self):
@@ -261,41 +270,40 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
     def test_export_stp_with_incorrect_args(self):
-        """Checks errors are raised when incorrect arguments are used
-        """
+        """Checks errors are raised when incorrect arguments are used"""
 
         def export_mode_incorrect():
-            self.test_shape.export_stp(
-                'test_solid.stp',
-                mode='coucou'
-            )
+            self.test_shape.export_stp("test_solid.stp", mode="coucou")
 
         self.assertRaises(ValueError, export_mode_incorrect)
 
     def test_graveyard_filename(self):
-        """Checks the name of the stp file for the Graveyard is correct
-        """
+        """Checks the name of the stp file for the Graveyard is correct"""
         output_filename = self.test_shape.export_graveyard()
-        assert 'graveyard.stp' == output_filename
+        assert "graveyard.stp" == output_filename
 
-        output_filename = self.test_shape.export_graveyard(filename='test.stp')
-        assert 'test.stp' == output_filename
+        output_filename = self.test_shape.export_graveyard(filename="test.stp")
+        assert "test.stp" == output_filename
 
     def test_incorrect_points_input(self):
         """Checks that an error is raised when the points are input with the
@@ -303,16 +311,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'straight'),
-                (10, 30, 'straight'),
-                (30, 30, 'straight'),
-                (30, 10, 'straight')
+                (10, 10, "straight"),
+                (10, 30, "straight"),
+                (30, 30, "straight"),
+                (30, 10, "straight"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_parametric_shapes/test_sweep_circle_shape.py b/tests/test_parametric_shapes/test_sweep_circle_shape.py
index 884ebfc74..efa007a1d 100644
--- a/tests/test_parametric_shapes/test_sweep_circle_shape.py
+++ b/tests/test_parametric_shapes/test_sweep_circle_shape.py
@@ -1,19 +1,17 @@
-
 import math
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateStraightShape, SweepCircleShape
 
 
 class TestSweepCircleShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = SweepCircleShape(
-            radius=10,
-            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)]
+            radius=10, path_points=[(50, 0), (30, 50), (70, 100), (50, 150)]
         )
 
     def test_default_parameters(self):
@@ -49,16 +47,14 @@ def invalid_relative_workplane_and_path_workplane():
             self.test_shape.path_workplane = "YZ"
 
         self.assertRaises(ValueError, workplane_and_path_workplane_equal)
-        self.assertRaises(
-            ValueError,
-            invalid_relative_workplane_and_path_workplane)
+        self.assertRaises(ValueError, invalid_relative_workplane_and_path_workplane)
 
     def test_absolute_shape_volume(self):
         """Creates a SweepCircleShape and checks that the volume is correct."""
 
         self.test_shape.path_points = [(50, 0), (50, 50), (50, 100)]
         assert self.test_shape.solid is not None
-        assert self.test_shape.volume() == pytest.approx(math.pi * 10**2 * 100)
+        assert self.test_shape.volume() == pytest.approx(math.pi * 10 ** 2 * 100)
 
     def test_relative_shape_volume_radius(self):
         """Creates two SweepCircleShapes and checks that their relative volume
@@ -66,8 +62,7 @@ def test_relative_shape_volume_radius(self):
 
         test_volume = self.test_shape.volume()
         self.test_shape.radius = 20
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 4, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 4, rel=0.01)
 
     def test_relative_shape_volume_azimuthal_placement(self):
         """Creates two SweepCircleShapes and checks that their relative volumes
@@ -75,8 +70,7 @@ def test_relative_shape_volume_azimuthal_placement(self):
 
         test_volume = self.test_shape.volume()
         self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 4, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 4, rel=0.01)
 
     def test_points_equal_path_points(self):
         """Checks that shape.points = shape.path_points upon construction of a
@@ -96,24 +90,30 @@ def test_force_cross_section(self):
 
         self.test_shape.force_cross_section = True
 
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2), rel=0.01)) == 2
+        assert (
+            self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2), rel=0.01))
+            == 2
+        )
 
         cutting_shape = RotateStraightShape(
             points=[(0, 50), (0, 200), (100, 200), (100, 50)],
         )
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2), rel=0.01)) == 2
+        assert (
+            self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2), rel=0.01))
+            == 2
+        )
 
         cutting_shape = RotateStraightShape(
             points=[(0, 100), (0, 200), (100, 200), (100, 100)]
         )
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(math.pi * (10**2), rel=0.01)) == 2
+        assert (
+            self.test_shape.areas.count(pytest.approx(math.pi * (10 ** 2), rel=0.01))
+            == 2
+        )
 
     def test_force_cross_section_volume(self):
         """Checks that a SweepCircleShape with a larger volume is created when
@@ -136,18 +136,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
diff --git a/tests/test_parametric_shapes/test_sweep_mixed_shape.py b/tests/test_parametric_shapes/test_sweep_mixed_shape.py
index 134b7a759..ec092f038 100644
--- a/tests/test_parametric_shapes/test_sweep_mixed_shape.py
+++ b/tests/test_parametric_shapes/test_sweep_mixed_shape.py
@@ -1,19 +1,24 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateStraightShape, SweepMixedShape
 
 
 class TestSweepMixedShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = SweepMixedShape(
-            points=[(-10, -10, "straight"), (-10, 10, "spline"), (0, 20, "spline"),
-                    (10, 10, "circle"), (0, 0, "circle"), (10, -10, "straight")],
-            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)]
+            points=[
+                (-10, -10, "straight"),
+                (-10, 10, "spline"),
+                (0, 20, "spline"),
+                (10, 10, "circle"),
+                (0, 0, "circle"),
+                (10, -10, "straight"),
+            ],
+            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)],
         )
 
     def test_default_parameters(self):
@@ -40,13 +45,24 @@ def test_relative_shape_volume_points(self):
         """Creates two SweepMixedShapes and checks that their relative volumes
         are correct."""
 
-        self.test_shape.points = [(-10, -10, "straight"), (-10, 10, "spline"), (0, 20, "spline"),
-                                  (10, 10, "circle"), (0, 0, "circle"), (10, -10, "straight")]
+        self.test_shape.points = [
+            (-10, -10, "straight"),
+            (-10, 10, "spline"),
+            (0, 20, "spline"),
+            (10, 10, "circle"),
+            (0, 0, "circle"),
+            (10, -10, "straight"),
+        ]
         test_volume = self.test_shape.volume()
-        self.test_shape.points = [(-20, -20, "straight"), (-20, 20, "spline"), (0, 40, "spline"),
-                                  (20, 20, "circle"), (0, 0, "circle"), (20, -20, "straight")]
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 4, rel=0.01)
+        self.test_shape.points = [
+            (-20, -20, "straight"),
+            (-20, 20, "spline"),
+            (0, 40, "spline"),
+            (20, 20, "circle"),
+            (0, 0, "circle"),
+            (20, -20, "straight"),
+        ]
+        assert self.test_shape.volume() == pytest.approx(test_volume * 4, rel=0.01)
 
     def test_relative_shape_volume_azimuthal_placement(self):
         """Creates two SweepMixedShapes and checks that their relative volumes
@@ -54,8 +70,7 @@ def test_relative_shape_volume_azimuthal_placement(self):
 
         test_volume = self.test_shape.volume()
         self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 4, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 4, rel=0.01)
 
     def test_workplane_path_workplane_error_raises(self):
         """Checks that errors are raised when SweepMixedShapes are created with
@@ -70,9 +85,7 @@ def invalid_relative_workplane_and_path_workplane():
             self.test_shape.path_workplane = "YZ"
 
         self.assertRaises(ValueError, workplane_and_path_workplane_equal)
-        self.assertRaises(
-            ValueError,
-            invalid_relative_workplane_and_path_workplane)
+        self.assertRaises(ValueError, invalid_relative_workplane_and_path_workplane)
 
     def test_workplane_opposite_distance(self):
         """Checks that a SweepMixedShape can be created with workplane XZ and
@@ -91,22 +104,19 @@ def test_force_cross_section(self):
 
         test_area = round(min(self.test_shape.areas))
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
         cutting_shape = RotateStraightShape(
             points=[(0, 50), (0, 200), (100, 200), (100, 50)]
         )
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
         cutting_shape.points = [(0, 100), (0, 200), (100, 200), (100, 100)]
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
     def test_force_cross_section_volume(self):
         """Checks that a SweepMixedShape with a larger volume is created when
@@ -129,18 +139,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
diff --git a/tests/test_parametric_shapes/test_sweep_spline_shape.py b/tests/test_parametric_shapes/test_sweep_spline_shape.py
index 624240de9..b6bf9b23b 100644
--- a/tests/test_parametric_shapes/test_sweep_spline_shape.py
+++ b/tests/test_parametric_shapes/test_sweep_spline_shape.py
@@ -1,18 +1,17 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateStraightShape, SweepSplineShape
 
 
 class TestSweepSplineShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = SweepSplineShape(
             points=[(-10, 10), (10, 10), (10, -10), (-10, -10)],
-            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)]
+            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)],
         )
 
     def test_default_parameters(self):
@@ -42,8 +41,7 @@ def test_relative_shape_volume_points(self):
         self.test_shape.points = [(-20, 20), (20, 20), (20, -20), (-20, -20)]
         test_volume = self.test_shape.volume()
         self.test_shape.points = [(-10, 10), (10, 10), (10, -10), (-10, -10)]
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 0.25, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 0.25, rel=0.01)
 
     def test_relative_shape_volume_azimuthal_placement(self):
         """Creates two SweepSplineShapes and checks that their relative volumes
@@ -51,8 +49,7 @@ def test_relative_shape_volume_azimuthal_placement(self):
 
         test_volume = self.test_shape.volume()
         self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]
-        assert self.test_shape.volume() == pytest.approx(
-            test_volume * 4, rel=0.01)
+        assert self.test_shape.volume() == pytest.approx(test_volume * 4, rel=0.01)
 
     def test_force_cross_section(self):
         """Checks that a SweepSplineShape with the same cross-section at each path_point
@@ -62,22 +59,19 @@ def test_force_cross_section(self):
 
         test_area = round(min(self.test_shape.areas))
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
         cutting_shape = RotateStraightShape(
             points=[(0, 50), (0, 200), (100, 200), (100, 50)]
         )
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
         cutting_shape.points = [(0, 100), (0, 200), (100, 200), (100, 100)]
         self.test_shape.cut = cutting_shape
 
-        assert self.test_shape.areas.count(
-            pytest.approx(test_area, rel=0.01)) == 2
+        assert self.test_shape.areas.count(pytest.approx(test_area, rel=0.01)) == 2
 
     def test_force_cross_section_volume(self):
         """Checks that a SweepSplineShape with a larger volume is created when
@@ -100,18 +94,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -121,16 +119,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'spline'),
-                (10, 30, 'spline'),
-                (30, 30, 'spline'),
-                (30, 10, 'spline')
+                (10, 10, "spline"),
+                (10, 30, "spline"),
+                (30, 30, "spline"),
+                (30, 10, "spline"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_parametric_shapes/test_sweep_straight_shape.py b/tests/test_parametric_shapes/test_sweep_straight_shape.py
index 05483193a..4e284dc89 100644
--- a/tests/test_parametric_shapes/test_sweep_straight_shape.py
+++ b/tests/test_parametric_shapes/test_sweep_straight_shape.py
@@ -1,18 +1,17 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import pytest
+
 from paramak import RotateStraightShape, SweepStraightShape
 
 
 class TestSweepStraightShape(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = SweepStraightShape(
             points=[(-10, 10), (10, 10), (10, -10), (-10, -10)],
-            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)]
+            path_points=[(50, 0), (30, 50), (70, 100), (50, 150)],
         )
 
     def test_default_parameters(self):
@@ -90,18 +89,22 @@ def test_export_stp(self):
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
-        self.test_shape.export_stp('test_solid.stp', mode='solid')
-        self.test_shape.export_stp('test_solid2.stp')
-        self.test_shape.export_stp('test_wire.stp', mode='wire')
+        self.test_shape.export_stp("test_solid.stp", mode="solid")
+        self.test_shape.export_stp("test_solid2.stp")
+        self.test_shape.export_stp("test_wire.stp", mode="wire")
 
         assert Path("test_solid.stp").exists() is True
         assert Path("test_solid2.stp").exists() is True
         assert Path("test_wire.stp").exists() is True
 
-        assert Path("test_solid.stp").stat().st_size == \
-            Path("test_solid2.stp").stat().st_size
-        assert Path("test_wire.stp").stat().st_size < \
-            Path("test_solid2.stp").stat().st_size
+        assert (
+            Path("test_solid.stp").stat().st_size
+            == Path("test_solid2.stp").stat().st_size
+        )
+        assert (
+            Path("test_wire.stp").stat().st_size
+            < Path("test_solid2.stp").stat().st_size
+        )
 
         os.system("rm test_solid.stp test_solid2.stp test_wire.stp")
 
@@ -110,7 +113,7 @@ def test_export_brep(self):
 
         os.system("rm test_solid.brep")
 
-        self.test_shape.export_brep(filename='test_solid.brep')
+        self.test_shape.export_brep(filename="test_solid.brep")
 
         assert Path("test_solid.brep").exists() is True
 
@@ -122,12 +125,9 @@ def test_export_brep_without_extention(self):
 
         def missing_extention():
 
-            self.test_shape.export_brep(filename='test_solid_missing')
+            self.test_shape.export_brep(filename="test_solid_missing")
 
-        self.assertRaises(
-            ValueError,
-            missing_extention
-        )
+        self.assertRaises(ValueError, missing_extention)
 
     def test_incorrect_points_input(self):
         """Checks that an error is raised when the points are input with the
@@ -135,16 +135,13 @@ def test_incorrect_points_input(self):
 
         def incorrect_points_definition():
             self.test_shape.points = [
-                (10, 10, 'straight'),
-                (10, 30, 'straight'),
-                (30, 30, 'straight'),
-                (30, 10, 'straight')
+                (10, 10, "straight"),
+                (10, 30, "straight"),
+                (30, 30, "straight"),
+                (30, 10, "straight"),
             ]
 
-        self.assertRaises(
-            ValueError,
-            incorrect_points_definition
-        )
+        self.assertRaises(ValueError, incorrect_points_definition)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_reactor.py b/tests/test_reactor.py
index 68199d1f7..457f87dc1 100644
--- a/tests/test_reactor.py
+++ b/tests/test_reactor.py
@@ -1,41 +1,34 @@
-
 import json
 import os
 import unittest
 from pathlib import Path
 
 import cadquery as cq
-import paramak
 import pytest
 
+import paramak
+
 
 class TestReactor(unittest.TestCase):
-
     def setUp(self):
         self.test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)],
-            name='test_shape'
+            points=[(0, 0), (0, 20), (20, 20)], name="test_shape"
         )
 
         self.test_shape2 = paramak.ExtrudeStraightShape(
-            points=[(100, 100), (50, 100), (50, 50)], distance=20,
-            name='test_shape2'
+            points=[(100, 100), (50, 100), (50, 50)], distance=20, name="test_shape2"
         )
 
         test_shape_3 = paramak.PoloidalFieldCoilSet(
-            heights=[2, 2],
-            widths=[3, 3],
-            center_points=[(50, -100), (50, 100)]
+            heights=[2, 2], widths=[3, 3], center_points=[(50, -100), (50, 100)]
         )
 
         self.test_reactor = paramak.Reactor([self.test_shape])
 
-        self.test_reactor_2 = paramak.Reactor(
-            [self.test_shape, self.test_shape2])
+        self.test_reactor_2 = paramak.Reactor([self.test_shape, self.test_shape2])
 
         # this reactor has a compound shape in the geometry
-        self.test_reactor_3 = paramak.Reactor(
-            [self.test_shape, test_shape_3])
+        self.test_reactor_3 = paramak.Reactor([self.test_shape, test_shape_3])
 
     def test_reactor_export_stp_with_name_set_to_none(self):
         """Exports the reactor as separate files and as a single file"""
@@ -51,14 +44,14 @@ def incorrect_name():
 
     def test_reactor_export_stp(self):
         """Exports the reactor as separate files and as a single file"""
-        os.system('rm *.stp')
+        os.system("rm *.stp")
         self.test_reactor_2.export_stp(
-            filename=['RotateStraightShape.stp', 'ExtrudeStraightShape.stp']
+            filename=["RotateStraightShape.stp", "ExtrudeStraightShape.stp"]
         )
-        assert Path('RotateStraightShape.stp').is_file()
-        assert Path('ExtrudeStraightShape.stp').is_file()
-        self.test_reactor_2.export_stp(filename='single_file.stp', units='cm')
-        assert Path('single_file.stp').is_file()
+        assert Path("RotateStraightShape.stp").is_file()
+        assert Path("ExtrudeStraightShape.stp").is_file()
+        self.test_reactor_2.export_stp(filename="single_file.stp", units="cm")
+        assert Path("single_file.stp").is_file()
 
     def test_show_runs_without_error(self):
         """checks that the jupyter notebook (with cadquery addition) runs
@@ -70,7 +63,7 @@ def test_show_runs_without_error_when_names_are_set(self):
         """checks that the jupyter notebook (with cadquery addition) runs
         without error even when the .name property is set"""
 
-        self.test_reactor.shapes_and_components[0].name = 'test'
+        self.test_reactor.shapes_and_components[0].name = "test"
         self.test_reactor.show()
 
     def test_show_runs_without_error_when_compounds_are_used(self):
@@ -82,46 +75,36 @@ def test_show_runs_without_error_when_compounds_are_used(self):
             widths=[10, 20],
             casing_thicknesses=10,
             center_points=[(100, 200), (400, 400)],
-            name='test name'
+            name="test name",
         )
 
         test_reactor = paramak.Reactor([test_shape])
         test_reactor.show()
 
     def test_incorrect_graveyard_offset_too_small(self):
-
         def incorrect_graveyard_offset_too_small():
             """Set graveyard_offset as a negative number which should raise an error"""
 
             self.test_reactor.graveyard_offset = -3
 
-        self.assertRaises(
-            ValueError,
-            incorrect_graveyard_offset_too_small
-        )
+        self.assertRaises(ValueError, incorrect_graveyard_offset_too_small)
 
     def test_incorrect_graveyard_offset_wrong_type(self):
-
         def incorrect_graveyard_offset_wrong_type():
             """Set graveyard_offset as a string which should raise an error"""
 
-            self.test_reactor.graveyard_offset = 'coucou'
+            self.test_reactor.graveyard_offset = "coucou"
 
-        self.assertRaises(
-            TypeError,
-            incorrect_graveyard_offset_wrong_type
-        )
+        self.assertRaises(TypeError, incorrect_graveyard_offset_wrong_type)
 
     def test_largest_dimension_setting_and_getting_using_largest_shapes(self):
         """Makes a neutronics model and checks the default largest_dimension
         and that largest_dimension changes with largest_shapes"""
 
-        assert self.test_reactor.largest_dimension == 20.
+        assert self.test_reactor.largest_dimension == 20.0
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
-        test_shape2 = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 40), (40, 40)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
+        test_shape2 = paramak.RotateStraightShape(points=[(0, 0), (0, 40), (40, 40)])
 
         test_reactor = paramak.Reactor([test_shape, test_shape2])
         assert test_reactor.largest_dimension == 40
@@ -132,24 +115,19 @@ def test_largest_dimension_setting_and_getting_using_largest_shapes(self):
     def test_make_sector_wedge(self):
         """Checks that the wedge is not made when rotation angle is 360"""
         sector_wedge = self.test_reactor.make_sector_wedge(
-            height=100,
-            radius=100,
-            rotation_angle=360
+            height=100, radius=100, rotation_angle=360
         )
         assert sector_wedge is None
 
     def test_wrong_number_of_filenames(self):
-
         def test_stl_filename_list_length():
             test_shape = paramak.ExtrudeCircleShape(
                 points=[(20, 20)], radius=10, distance=10
             )
             my_reactor = paramak.Reactor([test_shape])
-            my_reactor.export_stl(['wrong.stl', 'number_of.stl', 'files.stl'])
+            my_reactor.export_stl(["wrong.stl", "number_of.stl", "files.stl"])
 
-        self.assertRaises(
-            ValueError,
-            test_stl_filename_list_length)
+        self.assertRaises(ValueError, test_stl_filename_list_length)
 
     def test_make_graveyard_accepts_offset_from_graveyard(self):
         """Creates a graveyard for a reactor and sets the graveyard_offset.
@@ -177,8 +155,7 @@ def test_reactor_creation_with_default_properties(self):
     def test_adding_component_to_reactor(self):
         """creates a Reactor object and checks that shapes can be added to it"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_shape.create_solid()
         test_reactor = paramak.Reactor([])
@@ -190,8 +167,7 @@ def test_graveyard_exists(self):
         """creates a Reactor object with one shape and checks that a graveyard
         can be produced using the make_graveyard method"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_shape.create_solid()
         test_reactor = paramak.Reactor([test_shape])
@@ -204,8 +180,7 @@ def test_graveyard_exists_solid_is_none(self):
         can be produced using the make_graveyard method when the solid
         attribute of the shape is None"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_shape.create_solid()
         test_reactor = paramak.Reactor([test_shape])
@@ -218,8 +193,7 @@ def test_export_graveyard(self):
         """creates a Reactor object with one shape and checks that a graveyard
         can be exported to a specified location using the make_graveyard method"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         os.system("rm my_graveyard.stp")
         os.system("rm graveyard.stp")
@@ -232,7 +206,8 @@ def test_export_graveyard(self):
         for filepath in [
             "graveyard.stp",
             "my_graveyard.stp",
-                "my_graveyard_without_ext.stp"]:
+            "my_graveyard_without_ext.stp",
+        ]:
             assert Path(filepath).exists() is True
             os.system("rm " + filepath)
 
@@ -243,13 +218,11 @@ def test_make_graveyard_offset(self):
         """checks that the graveyard can be exported with the correct default parameters
         and that these parameters can be changed"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         os.system("rm graveyard.stp")
         test_reactor = paramak.Reactor(
-            [test_shape],
-            graveyard_size=None,
-            graveyard_offset=100)
+            [test_shape], graveyard_size=None, graveyard_offset=100
+        )
         test_reactor.make_graveyard()
 
         graveyard_volume_1 = test_reactor.graveyard.volume()
@@ -268,8 +241,7 @@ def test_exported_stp_files_exist(self):
         method"""
 
         os.system("rm test_reactor/*.stp")
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
 
         os.system("rm test_reactor/test_shape.stp")
@@ -277,7 +249,7 @@ def test_exported_stp_files_exist(self):
 
         test_reactor = paramak.Reactor([test_shape])
 
-        test_reactor.export_stp('test_reactor/test_shape.stp')
+        test_reactor.export_stp("test_reactor/test_shape.stp")
 
         assert Path("test_reactor/test_shape.stp").exists() is True
 
@@ -286,13 +258,12 @@ def test_exported_stl_files_exist(self):
         of the reactor can be exported to a specified location using the
         export_stl method"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         os.system("rm test_reactor/test_shape.stl")
         test_reactor = paramak.Reactor([test_shape])
 
-        test_reactor.export_stl(filename='test_reactor/test_shape.stl')
+        test_reactor.export_stl(filename="test_reactor/test_shape.stl")
 
         assert Path("test_reactor/test_shape.stl").exists() is True
         os.system("rm test_reactor/test_shape.stl")
@@ -348,16 +319,11 @@ def test_export_svg_options(self):
         assert Path("r_marginTop.svg").exists() is True
         self.test_reactor.export_svg("r_showAxes.svg", showAxes=True)
         assert Path("r_showAxes.svg").exists() is True
-        self.test_reactor.export_svg(
-            "r_projectionDir.svg", projectionDir=(-1, -1, -1))
+        self.test_reactor.export_svg("r_projectionDir.svg", projectionDir=(-1, -1, -1))
         assert Path("r_projectionDir.svg").exists() is True
-        self.test_reactor.export_svg(
-            "r_strokeColor.svg", strokeColor=(
-                42, 42, 42))
+        self.test_reactor.export_svg("r_strokeColor.svg", strokeColor=(42, 42, 42))
         assert Path("r_strokeColor.svg").exists() is True
-        self.test_reactor.export_svg(
-            "r_hiddenColor.svg", hiddenColor=(
-                42, 42, 42))
+        self.test_reactor.export_svg("r_hiddenColor.svg", hiddenColor=(42, 42, 42))
         assert Path("r_hiddenColor.svg").exists() is True
         self.test_reactor.export_svg("r_showHidden.svg", showHidden=False)
         assert Path("r_showHidden.svg").exists() is True
@@ -372,12 +338,10 @@ def test_export_2d_image(self):
         method."""
 
         os.system("rm 2D_test_image.png")
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
-        returned_filename = test_reactor.export_2d_image(
-            filename="2D_test_image.png")
+        returned_filename = test_reactor.export_2d_image(filename="2D_test_image.png")
 
         assert Path(returned_filename).exists() is True
         os.system("rm 2D_test_image.png")
@@ -388,12 +352,10 @@ def test_export_2d_image_without_extension(self):
         method"""
 
         os.system("rm 2d_test_image.png")
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
-        returned_filename = test_reactor.export_2d_image(
-            filename="2d_test_image")
+        returned_filename = test_reactor.export_2d_image(filename="2d_test_image")
 
         assert Path(returned_filename).exists() is True
         os.system("rm 2d_test_image.png")
@@ -404,8 +366,7 @@ def test_export_html(self):
         method."""
 
         os.system("rm test_html.html")
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
         test_reactor.export_html(filename="test_html.html")
@@ -421,31 +382,21 @@ def test_export_3d_html(self):
         """Checks the 3d html file is exported by the export_html_3d method
         with the correct filename"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
 
         os.system("rm filename.html")
-        filename = test_reactor.export_html_3d('filename.html')
+        filename = test_reactor.export_html_3d("filename.html")
         if filename is not None:
             assert Path("filename.html").exists() is True
 
-    def test_tet_meshes_error(self):
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
-        test_shape.rotation_angle = 360
-        test_reactor = paramak.Reactor([test_shape])
-        assert test_reactor.tet_meshes is not None
-
     def test_largest_dimension(self):
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
         assert pytest.approx(test_reactor.largest_dimension, rel=0.1 == 20)
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (30, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (30, 20)])
         test_shape.rotation_angle = 360
         test_reactor = paramak.Reactor([test_shape])
         assert pytest.approx(test_reactor.largest_dimension, rel=0.1 == 30)
@@ -455,9 +406,9 @@ def test_shapes_and_components(self):
         shapes which should raise a ValueError"""
 
         def incorrect_shapes_and_components():
-            test_shape = paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)])
+            test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
             paramak.Reactor(test_shape)
+
         self.assertRaises(ValueError, incorrect_shapes_and_components)
 
     def test_graveyard_size_setting_type_checking(self):
@@ -465,9 +416,9 @@ def test_graveyard_size_setting_type_checking(self):
         which should raise a ValueError"""
 
         def incorrect_graveyard_size_type():
-            test_shape = paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)])
-            paramak.Reactor([test_shape], graveyard_size='coucou')
+            test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
+            paramak.Reactor([test_shape], graveyard_size="coucou")
+
         self.assertRaises(TypeError, incorrect_graveyard_size_type)
 
     def test_graveyard_size_setting_magnitude_checking(self):
@@ -475,9 +426,9 @@ def test_graveyard_size_setting_magnitude_checking(self):
         which should raise a ValueError"""
 
         def incorrect_graveyard_size_size():
-            test_shape = paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)])
+            test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
             paramak.Reactor([test_shape], graveyard_size=-10)
+
         self.assertRaises(ValueError, incorrect_graveyard_size_size)
 
     def test_graveyard_offset_setting_type_checking(self):
@@ -485,9 +436,9 @@ def test_graveyard_offset_setting_type_checking(self):
         which should raise a ValueError"""
 
         def incorrect_graveyard_offset_type():
-            test_shape = paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)])
-            paramak.Reactor([test_shape], graveyard_offset='coucou')
+            test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
+            paramak.Reactor([test_shape], graveyard_offset="coucou")
+
         self.assertRaises(TypeError, incorrect_graveyard_offset_type)
 
     def test_graveyard_offset_setting_magnitude_checking(self):
@@ -495,33 +446,33 @@ def test_graveyard_offset_setting_magnitude_checking(self):
         which should raise a ValueError"""
 
         def incorrect_graveyard_offset_size():
-            test_shape = paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)])
+            test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
             paramak.Reactor([test_shape], graveyard_offset=-10)
+
         self.assertRaises(ValueError, incorrect_graveyard_offset_size)
 
     def test_graveyard_error(self):
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         test_reactor = paramak.Reactor([test_shape])
 
         def str_graveyard_offset():
-            test_reactor.graveyard_offset = 'coucou'
+            test_reactor.graveyard_offset = "coucou"
+
         self.assertRaises(TypeError, str_graveyard_offset)
 
         def negative_graveyard_offset():
             test_reactor.graveyard_offset = -2
+
         self.assertRaises(ValueError, negative_graveyard_offset)
 
         def list_graveyard_offset():
             test_reactor.graveyard_offset = [1.2]
+
         self.assertRaises(TypeError, list_graveyard_offset)
 
     def test_compound_in_shapes(self):
-        shape1 = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
-        shape2 = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)])
+        shape1 = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
+        shape2 = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         shape3 = paramak.Shape()
         shape3.solid = cq.Compound.makeCompound(
             [a.val() for a in [shape1.solid, shape2.solid]]
@@ -533,9 +484,7 @@ def test_sector_wedge_with_360_returns_none(self):
         """Trys to make a sector wedge with full 360 degree rotation and checks
         that None is returned"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)]
-        )
+        test_shape = paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)])
         my_reactor = paramak.Reactor([test_shape])
         assert my_reactor.make_sector_wedge(rotation_angle=360) is None
 
@@ -549,39 +498,21 @@ def test_reactor_volume(self):
         assert isinstance(self.test_reactor_2.volume()[1], float)
         assert len(self.test_reactor.volume()) == 1
         assert len(self.test_reactor_2.volume()) == 2
-        assert sum(
-            self.test_reactor_2.volume()) > sum(
-            self.test_reactor.volume())
+        assert sum(self.test_reactor_2.volume()) > sum(self.test_reactor.volume())
         assert self.test_reactor_2.volume()[0] == self.test_reactor.volume()[0]
 
     def test_reactor_volume_spliting_compounds(self):
         """Checks the volumes returned by the .volume method with splitting of
         compounds set to True are correct"""
 
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=True), list)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=False), list)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=True)[0], list)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=True)[1], list)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=False)[0], float)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=False)[1], float)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=True)[1][0], float)
-        assert isinstance(
-            self.test_reactor_3.volume(
-                split_compounds=True)[1][1], float)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=True), list)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=False), list)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=True)[0], list)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=True)[1], list)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=False)[0], float)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=False)[1], float)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=True)[1][0], float)
+        assert isinstance(self.test_reactor_3.volume(split_compounds=True)[1][1], float)
         assert len(self.test_reactor_3.volume(split_compounds=True)) == 2
         assert len(self.test_reactor_3.volume(split_compounds=True)[1]) == 2
 
@@ -592,8 +523,8 @@ def test_reactor_volume_spliting_compounds(self):
         assert pytest.approx(vol_3, vol_1 + vol_2)
 
     def test_reactor_names(self):
-        'checks that the names attribute returns the expected results'
-        assert self.test_reactor_2.name == ['test_shape', 'test_shape2']
+        "checks that the names attribute returns the expected results"
+        assert self.test_reactor_2.name == ["test_shape", "test_shape2"]
 
 
 if __name__ == "__main__":
diff --git a/tests/test_shape.py b/tests/test_shape.py
index 207421de1..5cc7e01bf 100644
--- a/tests/test_shape.py
+++ b/tests/test_shape.py
@@ -1,17 +1,16 @@
-
 import json
 import os
 import unittest
 from pathlib import Path
 
-import paramak
 import pytest
 from cadquery import Plane
 from numpy.testing._private.utils import assert_
 
+import paramak
+
 
 class TestShape(unittest.TestCase):
-
     def setUp(self):
 
         self.my_shape = paramak.CenterColumnShieldHyperbola(
@@ -31,7 +30,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "straight"),
                 (110, 45, "straight"),
-            ]
+            ],
         )
         self.test_extrude_mixed_shape = paramak.ExtrudeMixedShape(
             distance=1,
@@ -43,7 +42,7 @@ def setUp(self):
                 (150, 100, "straight"),
                 (140, 75, "straight"),
                 (110, 45, "straight"),
-            ]
+            ],
         )
 
     def test_graveyard_size_setting_type_checking(self):
@@ -51,7 +50,8 @@ def test_graveyard_size_setting_type_checking(self):
         which should raise a ValueError"""
 
         def incorrect_graveyard_size_type():
-            self.my_shape.graveyard_size = 'coucou'
+            self.my_shape.graveyard_size = "coucou"
+
         self.assertRaises(TypeError, incorrect_graveyard_size_type)
 
     def test_graveyard_size_setting_magnitude_checking(self):
@@ -60,6 +60,7 @@ def test_graveyard_size_setting_magnitude_checking(self):
 
         def incorrect_graveyard_size_size():
             self.my_shape.graveyard_size = -10
+
         self.assertRaises(ValueError, incorrect_graveyard_size_size)
 
     def test_graveyard_error_when_no_offset_or_size(self):
@@ -69,7 +70,9 @@ def test_graveyard_error_when_no_offset_or_size(self):
         def incorrect_graveyard():
             test_shape = paramak.RotateStraightShape(
                 points=[(0, 0), (0, 20), (20, 20)],
-                graveyard_size=None, graveyard_offset=None)
+                graveyard_size=None,
+                graveyard_offset=None,
+            )
             test_shape.make_graveyard()
 
         self.assertRaises(ValueError, incorrect_graveyard)
@@ -85,8 +88,8 @@ def test_make_graveyard_offset(self):
         parameters and that these parameters can be changed"""
 
         test_shape = paramak.RotateStraightShape(
-            points=[(0, 0), (0, 20), (20, 20)],
-            graveyard_size=None)
+            points=[(0, 0), (0, 20), (20, 20)], graveyard_size=None
+        )
         os.system("rm graveyard.stp")
 
         test_shape.make_graveyard(graveyard_offset=50)
@@ -118,29 +121,21 @@ def test_azimuth_placement_angle_getting_setting(self):
         assert test_shape.azimuth_placement_angle == [0, 90, 180, 270]
 
     def test_incorrect_graveyard_offset_too_small(self):
-
         def incorrect_graveyard_offset_too_small():
             """Set graveyard_offset as a negative number which should raise an
             error"""
 
             self.my_shape.graveyard_offset = -3
 
-        self.assertRaises(
-            ValueError,
-            incorrect_graveyard_offset_too_small
-        )
+        self.assertRaises(ValueError, incorrect_graveyard_offset_too_small)
 
     def test_incorrect_graveyard_offset_wrong_type(self):
-
         def incorrect_graveyard_offset_wrong_type():
             """Set graveyard_offset as a string which should raise an error"""
 
-            self.my_shape.graveyard_offset = 'coucou'
+            self.my_shape.graveyard_offset = "coucou"
 
-        self.assertRaises(
-            TypeError,
-            incorrect_graveyard_offset_wrong_type
-        )
+        self.assertRaises(TypeError, incorrect_graveyard_offset_wrong_type)
 
     def test_missing_filename_arg_in_export_stp(self):
         """Checks that an error is raised when a stp export is requested
@@ -149,10 +144,7 @@ def test_missing_filename_arg_in_export_stp(self):
         def incorrect_args():
             self.my_shape.export_stp()
 
-        self.assertRaises(
-            TypeError,
-            incorrect_args
-        )
+        self.assertRaises(TypeError, incorrect_args)
 
     def test_missing_filename_arg_in_export_stl(self):
         """Checks that an error is raised when a stl export is requested
@@ -161,22 +153,16 @@ def test_missing_filename_arg_in_export_stl(self):
         def incorrect_args():
             self.my_shape.export_stl()
 
-        self.assertRaises(
-            TypeError,
-            incorrect_args
-        )
+        self.assertRaises(TypeError, incorrect_args)
 
     def test_incorrect_color_values(self):
         """Checks that an error is raised when the color of a shape is
         defined as an invalid string."""
 
         def incorrect_color_string():
-            paramak.Shape(color=('1', '0', '1'))
+            paramak.Shape(color=("1", "0", "1"))
 
-        self.assertRaises(
-            ValueError,
-            incorrect_color_string
-        )
+        self.assertRaises(ValueError, incorrect_color_string)
 
     def test_incorrect_workplane(self):
         """Creates Shape object with incorrect workplane and checks errors
@@ -253,7 +239,7 @@ def test_create_limits(self):
         """Creates a Shape object and checks that the create_limits function
         returns the expected values for x_min, x_max, z_min and z_max."""
 
-        test_shape = paramak.Shape(connection_type='straight')
+        test_shape = paramak.Shape(connection_type="straight")
 
         test_shape.points = [
             (0, 0),
@@ -280,6 +266,7 @@ def test_create_limits_error(self):
 
         def limits():
             test_shape.create_limits()
+
         self.assertRaises(ValueError, limits)
 
     def test_initial_solid_construction(self):
@@ -353,11 +340,11 @@ def test_export_html(self):
         )
 
         os.system("rm filename.html")
-        test_shape.export_html('filename')
+        test_shape.export_html("filename")
         assert Path("filename.html").exists() is True
         os.system("rm filename.html")
         test_shape.color = (1, 0, 0, 0.5)
-        test_shape.export_html('filename')
+        test_shape.export_html("filename")
         assert Path("filename.html").exists() is True
         os.system("rm filename.html")
 
@@ -369,34 +356,31 @@ def test_export_html_view_planes(self):
             points=[(0, 0), (0, 20), (20, 20), (20, 0)], rotation_angle=180
         )
 
-        for view_plane in ['XZ', 'XY', 'YZ', 'YX', 'ZY', 'ZX', 'RZ', 'XYZ']:
+        for view_plane in ["XZ", "XY", "YZ", "YX", "ZY", "ZX", "RZ", "XYZ"]:
             os.system("rm *.html")
-            test_shape.export_html(
-                filename='filename',
-                view_plane=view_plane
-            )
+            test_shape.export_html(filename="filename", view_plane=view_plane)
             assert Path("filename.html").exists() is True
 
     def test_export_html_with_points_None(self):
-        """Checks that an error is raised when points is None and export_html
-        """
+        """Checks that an error is raised when points is None and export_html"""
         test_shape = paramak.Shape()
 
         def export():
             test_shape.export_html("out.html")
+
         self.assertRaises(ValueError, export)
 
     def test_export_html_with_wire_None(self):
-        """Checks that an error is raised when wire is None and export_html
-        """
+        """Checks that an error is raised when wire is None and export_html"""
         test_shape = paramak.Shape(
             points=[(0, 0), (0, 20), (20, 20), (20, 0)],
-            connection_type='straight',
+            connection_type="straight",
         )
         test_shape.wire = None
 
         def export():
             test_shape.export_html("out.html")
+
         self.assertRaises(ValueError, export)
 
     def test_export_3d_html(self):
@@ -408,7 +392,7 @@ def test_export_3d_html(self):
         )
 
         os.system("rm filename.html")
-        filename = test_shape.export_html_3d('filename.html')
+        filename = test_shape.export_html_3d("filename.html")
         if filename is not None:
             assert Path("filename.html").exists() is True
 
@@ -420,7 +404,7 @@ def invalid_filename_suffix():
             test_shape = paramak.RotateStraightShape(
                 points=[(0, 0), (0, 20), (20, 20)],
             )
-            test_shape.export_stp(filename='test_shape.txt')
+            test_shape.export_stp(filename="test_shape.txt")
 
         self.assertRaises(ValueError, invalid_filename_suffix)
 
@@ -441,7 +425,7 @@ def invalid_filename_suffix():
             test_shape = paramak.RotateStraightShape(
                 points=[(0, 0), (0, 20), (20, 20)],
             )
-            test_shape.export_stl(filename='test_shape.txt')
+            test_shape.export_stl(filename="test_shape.txt")
 
         self.assertRaises(ValueError, invalid_filename_suffix)
 
@@ -459,18 +443,14 @@ def test_invalid_color(self):
 
         def invalid_color_type():
 
-            paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)],
-                color=255
-            )
+            paramak.RotateStraightShape(points=[(0, 0), (0, 20), (20, 20)], color=255)
 
         self.assertRaises(ValueError, invalid_color_type)
 
         def invalid_color_length():
 
             paramak.RotateStraightShape(
-                points=[(0, 0), (0, 20), (20, 20)],
-                color=(255, 255, 255, 1, 1)
+                points=[(0, 0), (0, 20), (20, 20)], color=(255, 255, 255, 1, 1)
             )
 
         self.assertRaises(ValueError, invalid_color_length)
@@ -480,9 +460,7 @@ def test_volumes_add_up_to_total_volume_Compound(self):
         and that the volumes sum to equalt the volume for a Compound."""
 
         test_shape = paramak.PoloidalFieldCoilSet(
-            heights=[10, 10],
-            widths=[20, 20],
-            center_points=[(15, 15), (50, 50)]
+            heights=[10, 10], widths=[20, 20], center_points=[(15, 15), (50, 50)]
         )
 
         assert isinstance(test_shape.volume(), float)
@@ -490,38 +468,32 @@ def test_volumes_add_up_to_total_volume_Compound(self):
         assert isinstance(test_shape.volume(split_compounds=True)[0], float)
         assert isinstance(test_shape.volume(split_compounds=True)[1], float)
         assert len(test_shape.volume(split_compounds=True)) == 2
-        assert sum(
-            test_shape.volume(
-                split_compounds=True)) == pytest.approx(
-            test_shape.volume())
+        assert sum(test_shape.volume(split_compounds=True)) == pytest.approx(
+            test_shape.volume()
+        )
 
     def test_volumes_add_up_to_total_volume(self):
         """Checks the volume and volumes attributes are correct types
         and that the volumes sum to equalt the volume."""
 
         test_shape = paramak.PoloidalFieldCoil(
-            center_point=(100, 100),
-            height=50,
-            width=50
+            center_point=(100, 100), height=50, width=50
         )
 
         assert isinstance(test_shape.volume(), float)
         assert isinstance(test_shape.volume(split_compounds=True), list)
         assert isinstance(test_shape.volume(split_compounds=True)[0], float)
         assert len(test_shape.volume(split_compounds=True)) == 1
-        assert sum(
-            test_shape.volume(
-                split_compounds=True)) == pytest.approx(
-            test_shape.volume())
+        assert sum(test_shape.volume(split_compounds=True)) == pytest.approx(
+            test_shape.volume()
+        )
 
     def test_areas_add_up_to_total_area_Compound(self):
         """Checks the area and areas attributes are correct types
         and that the areas sum to equalt the area for a Compound."""
 
         test_shape = paramak.PoloidalFieldCoilSet(
-            heights=[10, 10],
-            widths=[20, 20],
-            center_points=[(15, 15), (50, 50)]
+            heights=[10, 10], widths=[20, 20], center_points=[(15, 15), (50, 50)]
         )
 
         assert isinstance(test_shape.area, float)
@@ -542,9 +514,7 @@ def test_areas_add_up_to_total_area(self):
         and that the areas sum to equalt the area."""
 
         test_shape = paramak.PoloidalFieldCoil(
-            center_point=(100, 100),
-            height=50,
-            width=50
+            center_point=(100, 100), height=50, width=50
         )
 
         assert isinstance(test_shape.area, float)
@@ -563,16 +533,14 @@ def test_create_patch_error(self):
 
         def patch():
             test_shape._create_patch()
+
         self.assertRaises(ValueError, patch)
 
     def test_create_patch_alpha(self):
         """Checks _create_patch returns a patch when alpha is given."""
 
         test_shape = paramak.PoloidalFieldCoil(
-            center_point=(100, 100),
-            height=50,
-            width=50,
-            color=(0.5, 0.5, 0.5, 0.1)
+            center_point=(100, 100), height=50, width=50, color=(0.5, 0.5, 0.5, 0.1)
         )
         assert test_shape._create_patch() is not None
 
@@ -604,31 +572,12 @@ def name_int():
             test_shape.name = 1
 
         def name_list():
-            test_shape.name = ['coucou']
+            test_shape.name = ["coucou"]
 
         self.assertRaises(ValueError, name_float)
         self.assertRaises(ValueError, name_int)
         self.assertRaises(ValueError, name_list)
 
-    def test_tet_mesh_error(self):
-        """Checks an error is raised when invalid value for tet_mesh is set.
-        """
-
-        test_shape = paramak.Shape()
-
-        def tet_mesh_float():
-            test_shape.tet_mesh = 2.0
-
-        def tet_mesh_int():
-            test_shape.tet_mesh = 1
-
-        def tet_mesh_list():
-            test_shape.tet_mesh = ['coucou']
-
-        self.assertRaises(ValueError, tet_mesh_float)
-        self.assertRaises(ValueError, tet_mesh_int)
-        self.assertRaises(ValueError, tet_mesh_list)
-
     def test_workplane_of_type_cadquery_plane(self):
         """Tests that a Cadquery.Plane is accepted as a workplane entry"""
 
@@ -691,7 +640,7 @@ def test_rotation_axis_error(self):
             "coucou",
             2,
             2.2,
-            [(1, 1, 1), 'coucou'],
+            [(1, 1, 1), "coucou"],
             [(1, 1, 1), 1],
             [(1, 1, 1), 1.0],
             [(1, 1, 1), (1, 1, 1)],
@@ -699,7 +648,7 @@ def test_rotation_axis_error(self):
             [(1, 1, 1, 2), (1, 0, 2)],
             [(1, 1, 2), [1, 0, 2]],
             [(1, 1, 1)],
-            [(1, 1, 1), (1, 'coucou', 1)],
+            [(1, 1, 1), (1, "coucou", 1)],
             [(1, 1, 1), (1, 0, 1), (1, 2, 3)],
         ]
         shape = paramak.Shape()
@@ -734,12 +683,8 @@ def test_reuse_points_between_shapes(self):
             (250, 50, "straight"),
             (200, 100, "straight"),
         ]
-        paramak.Shape(
-            points=points
-        )
-        paramak.Shape(
-            points=points
-        )
+        paramak.Shape(points=points)
+        paramak.Shape(points=points)
 
     def test_reuse_points_and_connections(self):
         """Checks that points can be reused between shapes"""
@@ -749,9 +694,7 @@ def test_reuse_points_and_connections(self):
             (250, 50, "straight"),
             (200, 100, "straight"),
         ]
-        test_shape = paramak.Shape(
-            points=points
-        )
+        test_shape = paramak.Shape(points=points)
 
         assert test_shape.points == [
             (100, 0, "straight"),
@@ -768,10 +711,7 @@ def test_reuse_points(self):
             (250, 50),
             (200, 100),
         ]
-        test_shape = paramak.Shape(
-            points=points,
-            connection_type='straight'
-        )
+        test_shape = paramak.Shape(points=points, connection_type="straight")
 
         assert test_shape.points == [
             (100, 0),
diff --git a/tests/test_utils.py b/tests/test_utils.py
index a22a36220..8c069deab 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,28 +1,30 @@
-
 import os
 import unittest
 from pathlib import Path
 
 import numpy as np
-import paramak
 import plotly.graph_objects as go
 import pytest
-from paramak.utils import (EdgeLengthSelector, FaceAreaSelector,
-                           extract_points_from_edges, facet_wire,
-                           find_center_point_of_circle, plotly_trace)
 
+import paramak
+from paramak.utils import (
+    EdgeLengthSelector,
+    FaceAreaSelector,
+    extract_points_from_edges,
+    facet_wire,
+    find_center_point_of_circle,
+    plotly_trace,
+    find_radius_of_circle,
+)
 
-class TestUtilityFunctions(unittest.TestCase):
 
+class TestUtilityFunctions(unittest.TestCase):
     def test_convert_circle_to_spline(self):
         """Tests the conversion of 3 points on a circle into points on a spline
         curve."""
 
         new_points = paramak.utils.convert_circle_to_spline(
-            p_0=(200., 0.),
-            p_1=(250., 50.),
-            p_2=(200., 100.),
-            tolerance=0.2
+            p_0=(200.0, 0.0), p_1=(250.0, 50.0), p_2=(200.0, 100.0), tolerance=0.2
         )
 
         # these points can change from 200. to values like 200.00000000000009
@@ -32,10 +34,7 @@ def test_convert_circle_to_spline(self):
         assert pytest.approx(new_points[-1][1], abs=0.0000000000001) == 100
 
         new_points_more_details = paramak.utils.convert_circle_to_spline(
-            p_0=(200, 0),
-            p_1=(250, 50),
-            p_2=(200, 100),
-            tolerance=0.1
+            p_0=(200, 0), p_1=(250, 50), p_2=(200, 100), tolerance=0.1
         )
 
         assert len(new_points_more_details) > len(new_points)
@@ -46,13 +45,12 @@ def test_extract_points_from_edges(self):
 
         test_points = [(1, 1), (3, 1), (4, 2)]
         test_shape = paramak.ExtrudeStraightShape(
-            points=test_points,
-            distance=6,
-            workplane='YZ')
+            points=test_points, distance=6, workplane="YZ"
+        )
 
         edges = facet_wire(wire=test_shape.wire)
 
-        points = extract_points_from_edges(edges=edges, view_plane='YZ')
+        points = extract_points_from_edges(edges=edges, view_plane="YZ")
 
         assert len(points) == 6
 
@@ -61,8 +59,7 @@ def test_extract_points_from_edges(self):
             assert isinstance(point[0], float)
             assert isinstance(point[1], float)
 
-        points_single_edge = extract_points_from_edges(
-            edges=edges[0], view_plane='YZ')
+        points_single_edge = extract_points_from_edges(edges=edges[0], view_plane="YZ")
 
         assert len(points) > len(points_single_edge)
         for point in points_single_edge:
@@ -70,8 +67,7 @@ def test_extract_points_from_edges(self):
             assert isinstance(point[0], float)
             assert isinstance(point[1], float)
 
-        points_single_edge = extract_points_from_edges(
-            edges=edges[0], view_plane='XYZ')
+        points_single_edge = extract_points_from_edges(edges=edges[0], view_plane="XYZ")
 
         assert len(points) > len(points_single_edge)
         for point in points_single_edge:
@@ -83,13 +79,9 @@ def test_extract_points_from_edges(self):
     def test_trace_creation(self):
         """Creates a plotly trace and checks the type returned"""
         trace = plotly_trace(
-            points=[
-                (0, 20),
-                (20, 0),
-                (0, -20)
-            ],
-            mode='markers+lines',
-            color=(10, 10, 10, 0.5)
+            points=[(0, 20), (20, 0), (0, -20)],
+            mode="markers+lines",
+            color=(10, 10, 10, 0.5),
         )
 
         assert isinstance(trace, go.Scatter)
@@ -97,13 +89,9 @@ def test_trace_creation(self):
     def test_trace_creation_3d(self):
         """Creates a 3d plotly trace and checks the type returned"""
         trace = plotly_trace(
-            points=[
-                (0, 20, 0),
-                (20, 0, 10),
-                (0, -20, -10)
-            ],
-            mode='markers+lines',
-            color=(10, 10, 10)
+            points=[(0, 20, 0), (20, 0, 10), (0, -20, -10)],
+            mode="markers+lines",
+            color=(10, 10, 10),
         )
 
         assert isinstance(trace, go.Scatter3d)
@@ -116,21 +104,26 @@ def test_find_center_point_of_circle(self):
         point_b = (20, 0)
         point_3 = (0, -20)
 
-        assert find_center_point_of_circle(
-            point_a, point_b, point_3) == (
-            (0, 0), 20)
+        assert find_center_point_of_circle(point_a, point_b, point_3) == (0, 0)
+
+    def test_find_radius_circle(self):
+        """passes and edge point and the center point of a circle in to the
+        function and checks the radius is calculated correctly"""
+
+        edge_point = (0, 20)
+        center_point = (0, 0)
+
+        assert find_radius_of_circle(center_point, edge_point) == 20
 
     def test_EdgeLengthSelector_with_fillet_areas(self):
         """tests the filleting of a RotateStraightShape results in an extra
         surface area"""
 
-        test_shape = paramak.RotateStraightShape(
-            points=[(1, 1), (2, 1), (2, 2)])
+        test_shape = paramak.RotateStraightShape(points=[(1, 1), (2, 1), (2, 2)])
 
         assert len(test_shape.areas) == 3
 
-        test_shape.solid = test_shape.solid.edges(
-            EdgeLengthSelector(6.28)).fillet(0.1)
+        test_shape.solid = test_shape.solid.edges(EdgeLengthSelector(6.28)).fillet(0.1)
 
         assert len(test_shape.areas) == 4
 
@@ -138,22 +131,19 @@ def test_FaceAreaSelector_with_fillet_areas(self):
         """tests the filleting of a ExtrudeStraightShape"""
 
         test_shape = paramak.ExtrudeStraightShape(
-            distance=5, points=[(1, 1), (2, 1), (2, 2)])
+            distance=5, points=[(1, 1), (2, 1), (2, 2)]
+        )
 
         assert len(test_shape.areas) == 5
 
-        test_shape.solid = test_shape.solid.faces(
-            FaceAreaSelector(0.5)).fillet(0.1)
+        test_shape.solid = test_shape.solid.faces(FaceAreaSelector(0.5)).fillet(0.1)
 
         assert len(test_shape.areas) == 11
 
     def test_find_center_point_of_circle_zero_det(self):
-        """Checks that None is given if det is zero
-        """
+        """Checks that None is given if det is zero"""
         point_a = (0, 0)
         point_b = (0, 0)
         point_3 = (0, 0)
 
-        assert find_center_point_of_circle(
-            point_a, point_b, point_3) == (
-            None, np.inf)
+        assert find_center_point_of_circle(point_a, point_b, point_3) is None