diff --git a/materials/admin.py b/materials/admin.py
index 2832ee6..94b7bfb 100644
--- a/materials/admin.py
+++ b/materials/admin.py
@@ -14,6 +14,7 @@
 from fractions import Fraction
 from decimal import Decimal, ROUND_HALF_UP
 import re
+from .utils import parse_formula
 
 admin.site.site_header = mark_safe(f"{MATD3_NAME} database")
 
@@ -73,15 +74,15 @@ class SystemStoichiometryInline(nested_admin.NestedTabularInline):
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
         Stoichiometry_Elements.objects.filter(system_stoichiometry=obj).delete()
-        element_pattern = r"([A-Z][a-z]*):(\d+(?:\.\d+)?|\d+(?:\.\d+)?/\d+(?:\.\d+)?)"
-        elements = re.findall(element_pattern, obj.stoichiometry)
-        for element, count_str in elements:
-            if "/" in count_str:
-                numerator, denominator = count_str.split("/")
-                count = Decimal(numerator) / Decimal(denominator)
-            else:
-                count = Decimal(count_str)
-            # Format counts
+        # Remove chiral prefixes
+        formula = re.sub(r"(\(R/S\)-|\b[SR]-)", "", obj.stoichiometry)
+        # Parse the formula using the same logic
+        try:
+            element_counts = parse_formula(formula)
+        except Exception as e:
+            # Handle parsing errors if necessary
+            return
+        for element, count in element_counts.items():
             if count == count.to_integral():
                 count_formatted = str(count.to_integral())
             else:
diff --git a/materials/signals.py b/materials/signals.py
index e993fcc..06a8b80 100644
--- a/materials/signals.py
+++ b/materials/signals.py
@@ -9,83 +9,7 @@
 from fractions import Fraction
 from decimal import Decimal, ROUND_HALF_UP
 import re
-
-
-def parse_formula(formula):
-    # Updated regex to include decimal numbers and fractions inside brackets
-    token_pattern = r"([A-Z][a-z]?|\d+(\.\d+)?|\([\d\.]+(\/[\d\.]+)?\)|\{[\d\.]+(\/[\d\.]+)?\}|\[[\d\.]+(\/[\d\.]+)?\]|[\(\)\[\]\{\}])"
-    tokens = re.findall(token_pattern, formula)
-    # Flatten the tokens list
-    tokens = [token[0] for token in tokens]
-    if not tokens:
-        return {}
-    stack = [{}]
-    bracket_stack = []
-    i = 0
-    while i < len(tokens):
-        token = tokens[i]
-        if token in "([{":
-            stack.append({})
-            bracket_stack.append(token)
-            i += 1
-        elif token in ")]}":
-            if not bracket_stack:
-                raise ValueError("Unmatched closing bracket in formula")
-            opening = bracket_stack.pop()
-            expected_closing = {"(": ")", "[": "]", "{": "}"}[opening]
-            if token != expected_closing:
-                raise ValueError("Mismatched brackets in formula")
-            top = stack.pop()
-            i += 1
-            multiplier = Decimal("1")
-            if i < len(tokens) and (
-                re.match(r"^\d+(\.\d+)?$", tokens[i])
-                or re.match(r"^[\(\[\{][\d\.]+(\/[\d\.]+)?[\)\]\}]$", tokens[i])
-            ):
-                if re.match(r"^[\(\[\{][\d\.]+\/[\d\.]+[\)\]\}]$", tokens[i]):
-                    # Handle fractions inside brackets
-                    fraction = tokens[i][1:-1].split("/")
-                    numerator = Decimal(fraction[0])
-                    denominator = Decimal(fraction[1])
-                    multiplier = numerator / denominator
-                elif re.match(r"^[\(\[\{][\d\.]+[\)\]\}]$", tokens[i]):
-                    # Handle decimal numbers inside brackets
-                    multiplier = Decimal(tokens[i][1:-1])
-                else:
-                    # Handle plain numbers
-                    multiplier = Decimal(tokens[i])
-                i += 1
-            for element, count in top.items():
-                stack[-1][element] = (
-                    stack[-1].get(element, Decimal("0")) + count * multiplier
-                )
-        elif re.match(r"^[A-Z][a-z]?$", token):
-            element = token
-            i += 1
-            count = Decimal("1")
-            if i < len(tokens) and (
-                re.match(r"^\d+(\.\d+)?$", tokens[i])
-                or re.match(r"^[\(\[\{][\d\.]+(\/[\d\.]+)?[\)\]\}]$", tokens[i])
-            ):
-                if re.match(r"^[\(\[\{][\d\.]+\/[\d\.]+[\)\]\}]$", tokens[i]):
-                    # Handle fractions inside brackets
-                    fraction = tokens[i][1:-1].split("/")
-                    numerator = Decimal(fraction[0])
-                    denominator = Decimal(fraction[1])
-                    count = numerator / denominator
-                elif re.match(r"^[\(\[\{][\d\.]+[\)\]\}]$", tokens[i]):
-                    # Handle decimal numbers inside brackets
-                    count = Decimal(tokens[i][1:-1])
-                else:
-                    # Handle plain numbers
-                    count = Decimal(tokens[i])
-                i += 1
-            stack[-1][element] = stack[-1].get(element, Decimal("0")) + count
-        else:
-            i += 1
-    if bracket_stack:
-        raise ValueError("Unmatched opening bracket in formula")
-    return stack[0]
+from .utils import parse_formula
 
 
 @receiver(post_save, sender=System)
diff --git a/materials/templates/materials/add_data.html b/materials/templates/materials/add_data.html
index 1a1d1a7..fe1c2c1 100644
--- a/materials/templates/materials/add_data.html
+++ b/materials/templates/materials/add_data.html
@@ -676,112 +676,217 @@ <h5 class="modal-title" id="stoichiometryModalLabel">Is this the correct stoichi
  </script>
   <script>
 
-    function parseFormula(formula) {
-        const tokens = formula.match(/([A-Z][a-z]?|\d+(\.\d+)?|\([\d\.]+(\/[\d\.]+)?\)|\{[\d\.]+(\/[\d\.]+)?\}|\[[\d\.]+(\/[\d\.]+)?\]|[\(\)\[\]\{\}])/g);
-        if (!tokens) return {};
-        const stack = [{}];
-        const bracketStack = [];
-        let i = 0;
-        while (i < tokens.length) {
-            const token = tokens[i];
-            if ('([{'.includes(token)) {
-                stack.push({});
-                bracketStack.push(token);
-                i++;
-            } else if (')]}'.includes(token)) {
-                if (!bracketStack.length) {
-                    console.error('Unmatched closing bracket in formula');
-                    return {};
-                }
-                const opening = bracketStack.pop();
-                const expectedClosing = { '(': ')', '[': ']', '{': '}' }[opening];
-                if (token !== expectedClosing) {
-                    console.error('Mismatched brackets in formula');
-                    return {};
-                }
-                const top = stack.pop();
+      <script>
+function parseFormula(formula) {
+    // Remove chiral prefixes (S-, R-, (R/S)-)
+    formula = formula.replace(/(\(R\/S\)-|\b[SR]-)/g, '');
+
+    // Define separators (excluding '.')
+    const separators = /[\•\-\:]/; // Include other separators if needed
+
+    // Tokenize the formula
+    const tokenPattern = /(\d+(\.\d+)?|[A-Z][a-z]?|[\(\)\[\]\{\}]|[\•\-\:]|[^\w\s])/g;
+    const tokens = formula.match(tokenPattern);
+    if (!tokens) return {};
+
+    const stack = [{ elementCounts: {}, multiplier: 1 }];
+    let i = 0;
+    let currentMultiplier = 1;
+
+    while (i < tokens.length) {
+        const token = tokens[i];
+
+        if (/^[A-Z][a-z]?$/.test(token)) {
+            const element = token;
+            i++;
+            let count = 1;
+            if (i < tokens.length && /^\d+(\.\d+)?$/.test(tokens[i])) {
+                count = parseFloat(tokens[i]);
                 i++;
-                let multiplier = 1;
-                if (i < tokens.length && (
-                    /^\d+(\.\d+)?$/.test(tokens[i]) ||
-                    /^[\(\[\{][\d\.]+(\/[\d\.]+)?[\)\]\}]$/.test(tokens[i])
-                )) {
-                    if (/^[\(\[\{][\d\.]+\/[\d\.]+[\)\]\}]$/.test(tokens[i])) {
-                        // Handle fractions inside brackets
-                        const fraction = tokens[i].slice(1, -1).split('/');
-                        multiplier = parseFloat(fraction[0]) / parseFloat(fraction[1]);
-                    } else if (/^[\(\[\{][\d\.]+[\)\]\}]$/.test(tokens[i])) {
-                        // Handle decimal numbers inside brackets
-                        multiplier = parseFloat(tokens[i].slice(1, -1));
-                    } else {
-                        // Handle plain numbers
-                        multiplier = parseFloat(tokens[i]);
-                    }
-                    i++;
-                }
-                for (const [element, count] of Object.entries(top)) {
-                    stack[stack.length - 1][element] =
-                        (stack[stack.length - 1][element] || 0) + count * multiplier;
-                }
-            } else if (/^[A-Z][a-z]?$/.test(token)) {
-                const element = token;
-                i++;
-                let count = 1;
-                if (i < tokens.length && (
-                    /^\d+(\.\d+)?$/.test(tokens[i]) ||
-                    /^[\(\[\{][\d\.]+(\/[\d\.]+)?[\)\]\}]$/.test(tokens[i])
-                )) {
-                    if (/^[\(\[\{][\d\.]+\/[\d\.]+[\)\]\}]$/.test(tokens[i])) {
-                        // Handle fractions inside brackets
-                        const fraction = tokens[i].slice(1, -1).split('/');
-                        count = parseFloat(fraction[0]) / parseFloat(fraction[1]);
-                    } else if (/^[\(\[\{][\d\.]+[\)\]\}]$/.test(tokens[i])) {
-                        // Handle decimal numbers inside brackets
-                        count = parseFloat(tokens[i].slice(1, -1));
-                    } else {
-                        // Handle plain numbers
-                        count = parseFloat(tokens[i]);
-                    }
-                    i++;
-                }
-                stack[stack.length - 1][element] =
-                    (stack[stack.length - 1][element] || 0) + count;
-            } else {
+            }
+            count *= currentMultiplier;
+            currentMultiplier = 1;
+            stack[stack.length - 1].elementCounts[element] = (stack[stack.length -1].elementCounts[element] || 0) + count;
+        } else if (/^\d+(\.\d+)?$/.test(token)) {
+            currentMultiplier = parseFloat(token);
+            i++;
+        } else if ('([{'.includes(token)) {
+            // Push new frame onto the stack
+            stack.push({ elementCounts: {}, multiplier: currentMultiplier });
+            currentMultiplier = 1;
+            i++;
+        } else if (')]}'.includes(token)) {
+            if (stack.length < 2) {
+                console.error('Unmatched closing bracket in formula');
+                return {};
+            }
+            // Pop the top frame
+            const { elementCounts: groupCounts, multiplier: groupMultiplier } = stack.pop();
+            i++;
+            let multiplierAfterBracket = 1;
+            if (i < tokens.length && /^\d+(\.\d+)?$/.test(tokens[i])) {
+                multiplierAfterBracket = parseFloat(tokens[i]);
                 i++;
             }
+            const totalMultiplier = groupMultiplier * multiplierAfterBracket;
+            for (const element in groupCounts) {
+                const count = groupCounts[element] * totalMultiplier;
+                stack[stack.length - 1].elementCounts[element] = (stack[stack.length -1].elementCounts[element] || 0) + count;
+            }
+        } else if (separators.test(token)) {
+            currentMultiplier = 1;
+            i++;
+        } else {
+            // Ignore any other tokens
+            i++;
         }
-        if (bracketStack.length > 0) {
-            console.error('Unmatched opening bracket in formula');
-            return {};
-        }
-        return stack[0];
     }
 
-    function extractStoichiometry() {
-        const formulaInput = document.getElementById('id_formula');
-        if (!formulaInput) {
-            console.error("Formula input not found");
-            return;
+    if (stack.length !== 1) {
+        console.error('Unmatched opening bracket in formula');
+        return {};
+    }
+
+    return stack[0].elementCounts;
+}
+
+function extractStoichiometry() {
+    const formulaInput = document.getElementById('id_formula');
+    if (!formulaInput) {
+        console.error("Formula input not found");
+        return;
+    }
+    const formula = formulaInput.value;
+    const elementCounts = parseFormula(formula);
+
+    let stoichiometryString = '';
+    for (const element in elementCounts) {
+        let count = elementCounts[element];
+        if (Number.isInteger(count)) {
+            count = count.toString();
+        } else {
+            count = parseFloat(count.toFixed(3)).toString();
         }
-        const formula = formulaInput.value;
-        const elementCounts = parseFormula(formula);
-
-        let stoichiometryString = '';
-        for (const element in elementCounts) {
-            let count = elementCounts[element];
-            if (Number.isInteger(count)) {
-                count = count.toString();
-            } else {
-                count = parseFloat(count.toFixed(3)).toString();
+        stoichiometryString += `${element}:${count}, `;
+    }
+    stoichiometryString = stoichiometryString.slice(0, -2);
+    document.getElementById('stoichiometryOutput').innerText = `${stoichiometryString}`;
+    $('#stoichiometryModal').modal('show');
+}
+</script>
+
+<script>
+    function parseFormula(formula) {
+    // Remove chiral prefixes (S-, R-, (R/S)-)
+    formula = formula.replace(/(\(R\/S\)-|\b[SR]-)/g, '');
+
+    // Define separators (excluding '.')
+    const separators = /[\u2022\-:]/; // Use Unicode escape for •
+
+    // Tokenize the formula
+    const tokenPattern = /(\d+(\.\d+)?|[A-Z][a-z]?|[\(\)\[\]\{\}]|[\u2022\-:])/g;
+    const tokens = formula.match(tokenPattern);
+    if (!tokens) return {};
+
+    const stack = [{}];
+    const multiplierStack = [1];
+    let i = 0;
+    let currentMultiplier = 1;
+
+    while (i < tokens.length) {
+        const token = tokens[i];
+
+        if (separators.test(token)) {
+            // Reset currentMultiplier
+            currentMultiplier = 1;
+            i++;
+            // Check for multiplier after separator
+            if (i < tokens.length && /^\d+(\.\d+)?$/.test(tokens[i])) {
+                currentMultiplier = parseFloat(tokens[i]);
+                i++;
             }
-            stoichiometryString += `${element}:${count}, `;
+        } else if (/^\d+(\.\d+)?$/.test(token)) {
+            // Multiplier before a bracket or element
+            currentMultiplier *= parseFloat(token);
+            i++;
+        } else if ('([{'.includes(token)) {
+            // Start of a new group
+            stack.push({});
+            // Push currentMultiplier onto multiplierStack
+            multiplierStack.push(currentMultiplier);
+            currentMultiplier = 1;
+            i++;
+        } else if (')]}'.includes(token)) {
+            if (stack.length === 1) {
+                console.error('Unmatched closing bracket in formula');
+                return {};
+            }
+            const group = stack.pop();
+            const groupMultiplier = multiplierStack.pop();
+            i++;
+            // Check for multiplier after closing bracket
+            let multiplierAfterBracket = 1;
+            if (i < tokens.length && /^\d+(\.\d+)?$/.test(tokens[i])) {
+                multiplierAfterBracket = parseFloat(tokens[i]);
+                i++;
+            }
+            const totalMultiplier = groupMultiplier * multiplierAfterBracket;
+            const currentGroup = stack[stack.length -1];
+            for (const element in group) {
+                const count = group[element] * totalMultiplier;
+                currentGroup[element] = (currentGroup[element] || 0) + count;
+            }
+        } else if (/^[A-Z][a-z]?$/.test(token)) {
+            const element = token;
+            i++;
+            let count = 1;
+            // Check if the next token is a number (count)
+            if (i < tokens.length && /^\d+(\.\d+)?$/.test(tokens[i])) {
+                count = parseFloat(tokens[i]);
+                i++;
+            }
+            // Multiply count by currentMultiplier
+            count *= currentMultiplier;
+            currentMultiplier = 1;
+            const currentGroup = stack[stack.length -1];
+            currentGroup[element] = (currentGroup[element] || 0) + count;
+        } else {
+            // Ignore any other tokens
+            i++;
         }
-        stoichiometryString = stoichiometryString.slice(0, -2);
-        document.getElementById('stoichiometryOutput').innerText = `${stoichiometryString}`;
-        $('#stoichiometryModal').modal('show');
     }
 
+    if (stack.length !== 1) {
+        console.error('Unmatched opening bracket in formula');
+        return {};
+    }
+
+    return stack[0];
+}
 
+function extractStoichiometry() {
+    const formulaInput = document.getElementById('id_formula');
+    if (!formulaInput) {
+        console.error("Formula input not found");
+        return;
+    }
+    const formula = formulaInput.value;
+    const elementCounts = parseFormula(formula);
+
+    let stoichiometryString = '';
+    for (const element in elementCounts) {
+        let count = elementCounts[element];
+        if (Number.isInteger(count)) {
+            count = count.toString();
+        } else {
+            count = parseFloat(count.toFixed(3)).toString();
+        }
+        stoichiometryString += `${element}:${count}, `;
+    }
+    stoichiometryString = stoichiometryString.slice(0, -2);
+    document.getElementById('stoichiometryOutput').innerText = `${stoichiometryString}`;
+    $('#stoichiometryModal').modal('show');
+}
 
     function handleStoichiometryConfirmation(answer){
       const stoichiometryTextBox = document.getElementById('system-stoichiometry-input');
diff --git a/materials/utils.py b/materials/utils.py
index b62853e..8ed4252 100644
--- a/materials/utils.py
+++ b/materials/utils.py
@@ -9,12 +9,94 @@
 
 from . import models
 from .models import System_Stoichiometry, Stoichiometry_Elements
+from decimal import Decimal
 
-matplotlib.use('Agg')  # noqa
-
+matplotlib.use("Agg")  # noqa
 from matplotlib import pyplot
 
 
+def parse_formula(formula):
+    # Remove chiral prefixes (S-, R-, (R/S)-)
+    formula = re.sub(r"(\(R/S\)-|\b[SR]-)", "", formula)
+
+    # Define separators (excluding '.')
+    separators = r"[\•\-\:]"  # Include other separators if needed
+
+    # Tokenize the formula
+    token_pattern = r"(\d+(\.\d+)?|[A-Z][a-z]?|[\(\)\[\]\{\}]|" + separators + r")"
+    tokens = re.findall(token_pattern, formula)
+    tokens = [token[0] for token in tokens]
+    if not tokens:
+        return {}
+
+    stack = [{}]
+    multiplier_stack = [Decimal("1")]
+    i = 0
+    current_multiplier = Decimal("1")
+
+    while i < len(tokens):
+        token = tokens[i]
+
+        if re.match(separators, token):
+            # Reset current_multiplier
+            current_multiplier = Decimal("1")
+            i += 1
+            # Check for multiplier after separator
+            if i < len(tokens) and re.match(r"^\d+(\.\d+)?$", tokens[i]):
+                current_multiplier = Decimal(tokens[i])
+                i += 1
+        elif re.match(r"^\d+(\.\d+)?$", token):
+            # Multiplier before a bracket or element
+            current_multiplier *= Decimal(token)
+            i += 1
+        elif token in "([{":
+            # Start of a new group
+            stack.append({})
+            # Push current_multiplier onto multiplier_stack
+            multiplier_stack.append(current_multiplier)
+            current_multiplier = Decimal("1")
+            i += 1
+        elif token in ")]}":
+            if len(stack) == 1:
+                raise ValueError("Unmatched closing bracket in formula")
+            group = stack.pop()
+            group_multiplier = multiplier_stack.pop()
+            i += 1
+            # Check for multiplier after closing bracket
+            multiplier_after_bracket = Decimal("1")
+            if i < len(tokens) and re.match(r"^\d+(\.\d+)?$", tokens[i]):
+                multiplier_after_bracket = Decimal(tokens[i])
+                i += 1
+            total_multiplier = group_multiplier * multiplier_after_bracket
+            current_group = stack[-1]
+            for element, count in group.items():
+                count *= total_multiplier
+                current_group[element] = (
+                    current_group.get(element, Decimal("0")) + count
+                )
+        elif re.match(r"^[A-Z][a-z]?$", token):
+            element = token
+            i += 1
+            count = Decimal("1")
+            # Check if the next token is a number (count)
+            if i < len(tokens) and re.match(r"^\d+(\.\d+)?$", tokens[i]):
+                count = Decimal(tokens[i])
+                i += 1
+            # Multiply count by current_multiplier
+            count *= current_multiplier
+            current_multiplier = Decimal("1")
+            current_group = stack[-1]
+            current_group[element] = current_group.get(element, Decimal("0")) + count
+        else:
+            # Ignore any other tokens
+            i += 1
+
+    if len(stack) != 1:
+        raise ValueError("Unmatched opening bracket in formula")
+
+    return stack[0]
+
+
 def atomic_coordinates_as_json(pk):
     """Get atomic coordinates from the atomic structure list.
 
@@ -24,36 +106,52 @@ def atomic_coordinates_as_json(pk):
 
     """
     subset = models.Subset.objects.get(pk=pk)
-    vectors = models.NumericalValue.objects.filter(
-        datapoint__subset=subset).filter(
-            datapoint__symbols__isnull=True).order_by(
-                'datapoint_id', 'counter')
-    data = {'vectors':
-            [[x.formatted('.10g') for x in vectors[:3]],
-             [x.formatted('.10g') for x in vectors[3:6]],
-             [x.formatted('.10g') for x in vectors[6:9]]]}
+    vectors = (
+        models.NumericalValue.objects.filter(datapoint__subset=subset)
+        .filter(datapoint__symbols__isnull=True)
+        .order_by("datapoint_id", "counter")
+    )
+    data = {
+        "vectors": [
+            [x.formatted(".10g") for x in vectors[:3]],
+            [x.formatted(".10g") for x in vectors[3:6]],
+            [x.formatted(".10g") for x in vectors[6:9]],
+        ]
+    }
     # Here counter=1 filters out the first six entries
-    symbols = models.Symbol.objects.filter(
-        datapoint__subset=subset).filter(counter=1).order_by(
-            'datapoint_id').values_list('value', flat=True)
-    coords = models.NumericalValue.objects.filter(
-        datapoint__subset=subset).filter(
-            datapoint__symbols__counter=1).select_related('error').order_by(
-                'counter', 'datapoint_id')
-    tmp = models.Symbol.objects.filter(
-        datapoint__subset=subset).annotate(
-            num=models.models.Count('datapoint__symbols')).filter(
-                num=2).first()
+    symbols = (
+        models.Symbol.objects.filter(datapoint__subset=subset)
+        .filter(counter=1)
+        .order_by("datapoint_id")
+        .values_list("value", flat=True)
+    )
+    coords = (
+        models.NumericalValue.objects.filter(datapoint__subset=subset)
+        .filter(datapoint__symbols__counter=1)
+        .select_related("error")
+        .order_by("counter", "datapoint_id")
+    )
+    tmp = (
+        models.Symbol.objects.filter(datapoint__subset=subset)
+        .annotate(num=models.models.Count("datapoint__symbols"))
+        .filter(num=2)
+        .first()
+    )
     if tmp:
-        data['coord-type'] = tmp.value
-    data['coordinates'] = []
-    N = int(len(coords)/3)
+        data["coord-type"] = tmp.value
+    data["coordinates"] = []
+    N = int(len(coords) / 3)
     for symbol, coord_x, coord_y, coord_z in zip(
-            symbols, coords[:N], coords[N:2*N], coords[2*N:3*N]):
-        data['coordinates'].append((symbol,
-                                    coord_x.formatted('.9g'),
-                                    coord_y.formatted('.9g'),
-                                    coord_z.formatted('.9g')))
+        symbols, coords[:N], coords[N : 2 * N], coords[2 * N : 3 * N]
+    ):
+        data["coordinates"].append(
+            (
+                symbol,
+                coord_x.formatted(".9g"),
+                coord_y.formatted(".9g"),
+                coord_z.formatted(".9g"),
+            )
+        )
     return data
 
 
@@ -74,19 +172,18 @@ def plot_band_structure(k_labels, files, dataset):
     # Compress k_labels into a 1-dim list. If the endpoint of a pairs
     # differs from the beginning of the next pair, use both labels
     # with a "|" in between.
-    k_labels_reduced = (len(k_labels)+1)*['']
+    k_labels_reduced = (len(k_labels) + 1) * [""]
     k_labels_reduced[0] = k_labels[0][0]
     for ik in range(len(k_labels)):
-        if ik < len(k_labels)-1 and k_labels[ik][1] != k_labels[ik+1][0]:
-            k_labels_reduced[ik+1] = f'{k_labels[ik][1]}|{k_labels[ik+1][0]}'
+        if ik < len(k_labels) - 1 and k_labels[ik][1] != k_labels[ik + 1][0]:
+            k_labels_reduced[ik + 1] = f"{k_labels[ik][1]}|{k_labels[ik+1][0]}"
         else:
-            k_labels_reduced[ik+1] = k_labels[ik][1]
+            k_labels_reduced[ik + 1] = k_labels[ik][1]
     # Use the gamma symbol where appropriate
     for ik in range(len(k_labels_reduced)):
-        k_labels_reduced[ik] = re.sub('[Gg](?:amma)?', 'Γ',
-                                      k_labels_reduced[ik])
+        k_labels_reduced[ik] = re.sub("[Gg](?:amma)?", "Γ", k_labels_reduced[ik])
     # A segment location is where a k-point should be displayed
-    segment_locations = numpy.empty(len(files)+1, dtype=int)
+    segment_locations = numpy.empty(len(files) + 1, dtype=int)
     segment_locations[0] = 0
     # Read in all data points (energies) next
     data_raw = []
@@ -97,37 +194,41 @@ def plot_band_structure(k_labels, files, dataset):
         n_kpoints.append(len(lines))
         # If the first k-point is the same as the last k-point of
         # the previous segment, it needs to be skipped.
-        skip_first = i_segment > 0 and '|' not in k_labels_reduced[i_segment]
+        skip_first = i_segment > 0 and "|" not in k_labels_reduced[i_segment]
         if skip_first:
             n_kpoints[-1] -= 1
             i_skip = 1
         else:
             i_skip = 0
-        segment_locations[i_segment+1] = sum(n_kpoints)-1
+        segment_locations[i_segment + 1] = sum(n_kpoints) - 1
         # Determine the number of bands from the first line of the
         # first file.
         if i_segment == 0:
             words = lines[0].split()
-            n_bands = int(len(words[5:])/2)
+            n_bands = int(len(words[5:]) / 2)
             min_index = int(1e10)
             max_index = 0
         data_raw.append(numpy.empty([n_kpoints[-1], n_bands]))
         for i_kpoint in range(n_kpoints[-1]):
-            words = lines[i_kpoint+i_skip].split()
-            n_bands_local = int((len(words)-5)/2)
+            words = lines[i_kpoint + i_skip].split()
+            n_bands_local = int((len(words) - 5) / 2)
             for i_band in range(min(n_bands, n_bands_local)):
-                band_energy = float(words[5+2*i_band])
-                occupation = float(words[4+2*i_band])
+                band_energy = float(words[5 + 2 * i_band])
+                occupation = float(words[4 + 2 * i_band])
                 data_raw[-1][i_kpoint, i_band] = band_energy
                 if occupation > 1e-10:
                     fermi_energy = max(fermi_energy, band_energy)
     for i_segment in range(len(data_raw)):
         data_raw[i_segment] -= fermi_energy
         for i_kpoint in range(n_kpoints[i_segment]):
-            min_index = min(min_index, numpy.searchsorted(
-                data_raw[i_segment][i_kpoint, :], ENERGY_FULL_MIN))
-            max_index = max(max_index, numpy.searchsorted(
-                data_raw[i_segment][i_kpoint, :], ENERGY_FULL_MAX))
+            min_index = min(
+                min_index,
+                numpy.searchsorted(data_raw[i_segment][i_kpoint, :], ENERGY_FULL_MIN),
+            )
+            max_index = max(
+                max_index,
+                numpy.searchsorted(data_raw[i_segment][i_kpoint, :], ENERGY_FULL_MAX),
+            )
         file_.close()
     # Reduce the full data because we are only interested in a small
     # energy window.
@@ -137,104 +238,105 @@ def plot_band_structure(k_labels, files, dataset):
     for i_segment in range(len(data_raw)):
         n_kpoints = data_raw[i_segment].shape[0]
         for i_kpoint in range(n_kpoints):
-            data[:, k_start+i_kpoint] = (
-                data_raw[i_segment][i_kpoint, min_index:max_index])
+            data[:, k_start + i_kpoint] = data_raw[i_segment][
+                i_kpoint, min_index:max_index
+            ]
         k_start += n_kpoints
     # Transfer the data into the plot
     x_ticks = range(data.shape[1])
     ax = pyplot.axes()
     for i_band in range(data.shape[0]):
-        ax.plot(x_ticks, data[i_band, :], color='blue', lw=1.0)
+        ax.plot(x_ticks, data[i_band, :], color="blue", lw=1.0)
     # Set x-axis labels
-    ax.xaxis.set_ticks_position('none')
-    x_labels = len(x_ticks)*['']
+    ax.xaxis.set_ticks_position("none")
+    x_labels = len(x_ticks) * [""]
     for i, loc in enumerate(segment_locations):
         x_labels[loc] = k_labels_reduced[i]
     pyplot.xticks(x_ticks, x_labels)
     ax.set_xlim(left=0, right=len(x_ticks))
     # Set y-axis label
-    pyplot.ylabel('Energy, eV')
+    pyplot.ylabel("Energy, eV")
     # Draw some vertical and horizontal helper lines
     for segment_i in segment_locations:
-        ax.axvline(x=segment_i, color='black', linestyle='--',
-                   lw=HELPER_LINE_WIDTH)
-    ax.axhline(y=0, color='black', linestyle='--', lw=HELPER_LINE_WIDTH)
+        ax.axvline(x=segment_i, color="black", linestyle="--", lw=HELPER_LINE_WIDTH)
+    ax.axhline(y=0, color="black", linestyle="--", lw=HELPER_LINE_WIDTH)
     # Save to file
     ax.set_ylim(bottom=ENERGY_FULL_MIN, top=ENERGY_FULL_MAX)
 
     def save_plot(name):
         in_memory_object = io.BytesIO()
-        pyplot.savefig(in_memory_object, format='png', bbox_inches='tight')
+        pyplot.savefig(in_memory_object, format="png", bbox_inches="tight")
         f = SimpleUploadedFile(name, in_memory_object.getvalue())
         dataset.files.create(created_by=dataset.created_by, dataset_file=f)
         in_memory_object.close()
 
-    save_plot('band_structure_full.png')
+    save_plot("band_structure_full.png")
     ax.set_ylim(bottom=ENERGY_SMALL_MIN, top=ENERGY_SMALL_MAX)
-    save_plot('band_structure_small.png')
+    save_plot("band_structure_small.png")
     pyplot.close()
 
 
 def dataset_info(dataset, server):
     """Return the data set contents as human-readable plain text."""
     data = io.StringIO()
-    data.write(
-        f'Data available at {server}/materials/dataset/{dataset.pk}\n')
-    data.write('\n')
+    data.write(f"Data available at {server}/materials/dataset/{dataset.pk}\n")
+    data.write("\n")
     if dataset.reference:
         ref = dataset.reference
-        data.write(f'Reference: {ref.getAuthorsAsString()} "{ref.title}", '
-                   f'{ref.journal} {ref.vol}')
+        data.write(
+            f'Reference: {ref.getAuthorsAsString()} "{ref.title}", '
+            f"{ref.journal} {ref.vol}"
+        )
         if ref.pages_start:
-            data.write(f', {ref.pages_start} ')
-        data.write(f' ({ref.year})\n')
-        data.write('\n')
+            data.write(f", {ref.pages_start} ")
+        data.write(f" ({ref.year})\n")
+        data.write("\n")
     data.write(
-        'Origin: '
-        f'{"experimental" if dataset.experimental else "theoretical"}\n')
-    data.write(f'Dimensionality: {dataset.dimensionality}D\n')
+        "Origin: " f'{"experimental" if dataset.experimental else "theoretical"}\n'
+    )
+    data.write(f"Dimensionality: {dataset.dimensionality}D\n")
     sample = models.Dataset.SAMPLE_TYPES[dataset.sample_type][1]
-    data.write(f'Sample type: {sample}\n')
-    data.write('\n')
+    data.write(f"Sample type: {sample}\n")
+    data.write("\n")
     if dataset.secondary_property:
-        data.write(f'Column 1: {dataset.secondary_property}')
+        data.write(f"Column 1: {dataset.secondary_property}")
         if dataset.secondary_unit:
-            data.write(f', {dataset.secondary_unit}')
-        data.write('\n')
-        data.write('Column 2: ')
+            data.write(f", {dataset.secondary_unit}")
+        data.write("\n")
+        data.write("Column 2: ")
     else:
-        data.write('Physical property: ')
+        data.write("Physical property: ")
     data.write(dataset.primary_property.name)
     if dataset.primary_unit:
-        data.write(f', {dataset.primary_unit}')
-    data.write('\n\n')
+        data.write(f", {dataset.primary_unit}")
+    data.write("\n\n")
     for subset in dataset.subsets.all():
         if subset.label:
-            data.write(f'{subset.label}\n')
+            data.write(f"{subset.label}\n")
         fixed_values = subset.fixed_values.all()
         if fixed_values:
-            data.write('Fixed parameters:\n')
+            data.write("Fixed parameters:\n")
         for v in fixed_values:
-            data.write(f'  {v.physical_property} = {v.value} {v.unit}\n')
-        if dataset.primary_property.name == 'atomic structure':
+            data.write(f"  {v.physical_property} = {v.value} {v.unit}\n")
+        if dataset.primary_property.name == "atomic structure":
             for symbol, value, unit in subset.get_lattice_constants():
-                data.write(f'{symbol} {value}{unit}\n')
-        elif dataset.primary_property.name.startswith('phase transition '):
+                data.write(f"{symbol} {value}{unit}\n")
+        elif dataset.primary_property.name.startswith("phase transition "):
             pt = subset.phase_transitions.first()
             CS = models.Subset.CRYSTAL_SYSTEMS
-            data.write('Initial crystal system: '
-                       f'{CS[subset.crystal_system][1]}\n')
+            data.write("Initial crystal system: " f"{CS[subset.crystal_system][1]}\n")
             if pt.crystal_system_final:
-                data.write('Final crystal system: '
-                           f'{CS[pt.crystal_system_final][1]}\n')
+                data.write(
+                    "Final crystal system: " f"{CS[pt.crystal_system_final][1]}\n"
+                )
             if pt.space_group_initial:
-                data.write(f'Space group initial: {pt.space_group_initial}\n')
+                data.write(f"Space group initial: {pt.space_group_initial}\n")
             if pt.space_group_final:
-                data.write(f'Space group final: {pt.space_group_final}\n')
+                data.write(f"Space group final: {pt.space_group_final}\n")
             if pt.direction:
-                data.write(f'Direction: {pt.direction}\n')
+                data.write(f"Direction: {pt.direction}\n")
             if pt.hysteresis:
-                data.write(f'Hysteresis: {pt.hysteresis}\n')
-            data.write(f'Value: {pt.formatted()}\n')
-        data.write('\n\n')
+                data.write(f"Hysteresis: {pt.hysteresis}\n")
+            data.write(f"Value: {pt.formatted()}\n")
+        data.write("\n\n")
     return data.getvalue()