f06_query.py

import math
import sys
from io import TextIOWrapper

# =======================================
# F06 parser for Mystran and MSC variants
# =======================================
#
# Example usage:
#
#   from f06_query import F06Query
#   f06 = F06Query("my_filename.f06")
#   print(f06.get_layer_0(["SC", "1", "DISPLACEMENTS", "GID", "2", "TZ"]))
#
# It stores the data hierarchically in a nested dictionary.
#
# Supported blocks and their fields:
#
# DISPLACEMENTS: TX, TY, TZ, RX, RY, RZ
# SPCFORCES: TX, TY, TZ, RX, RY, RZ
# MPCFORCES: TX, TY, TZ, RX, RY, RZ
# APPLIEDFORCES: TX, TY, TZ, RX, RY, RZ
# GPFORCE: TX, TY, TZ, RX, RY, RZ for each force type (APPLIED, SPC, MPC, THERMAL, INERTIA, EID/\*)
#   MSC: No INERTIA because it doesn't include that.
# ELASFORCES
# ELASSTRESSES
# ELASSTRAINS
#   Mystran: No because it doesn't output elas strains
# RODFORCES: AXIAL, TORQUE
# RODSTRESSES: AXIAL, AXIALSAFETY, TORSIONAL, TORSIONALSAFETY
# RODSTRAINS: AXIAL, AXIALSAFETY, TORSIONAL, TORSIONALSAFETY
#   Mystran: No because it doesn't output rod strains
# BARFORCES: MA1, MA2, MB1, MB2, S1, S2, AXIAL, TORQUE
# BARSTRESSES: SA1, SA2, SA3, SA4, SB1, SB2, SB3, SB4, AXIAL
# BUSHFORCES: TX, TY, TZ, RX, RY, RZ
# BUSHSTRESSES: TX, TY, TZ, RX, RY, RZ
# BUSHSTRAINS: TX, TY, TZ, RX, RY, RZ
# SHELLFORCES: GID, NXX, NYY, NXY, MXX, MYY, MXY, QX, QY for each CORNER
# SHELLSTRESSES: XX, YY, XY, PRINCIPALANGLE, VONMISES for each CORNER and Z1/Z2. GID, ZX, YZ for each CORNER
#   MSC: No ZX,YZ because it doesn't have them. No CQUAD8 because I don't have examples.
# SHELLSTRAINS: XX, YY, XY, PRINCIPALANGLE for each CORNER and Z1/Z2. GID, ZX, YZ for each CORNER
#   MSC: No ZX,YZ because it doesn't have them. No CQUAD8 because I don't have examples.
# COMPOSITESTRESSES: 11, 22, 12, 13, 23 for each PLY
#   MSC: No because I don't have examples and it seems to be enabled differently from Mystran.
# SOLIDSTRESSES: GID, XX, YY, ZZ, XY, YZ, ZX, VONMISES
# SOLIDSTRAINS: GID, XX, YY, ZZ, XY, YZ, ZX, VONMISES
# EIGENVECTOR: TX, TY, TZ, RX, RY, RZ
# REALEIGENVALUES: EIGENVALUE, CYCLES
#   Mystran: No CYCLES for SOL 105 because it doesn't have that.
#
# For MSC, the only blocks that can read in a mode are:
#   EIGENVECTOR
#   GPFORCE
# because other blocks identify their mode by its eigenvalue which may be non-unique.

# Caller should handle only this exception type when instantiating the class.
class ReadFail(Exception):
    pass

INDENT = "  "

class F06Query:
  
    def __init__(self, file_name):
        self.file_name = file_name

        try:
            # Unicode by default for U-dot-dot character in GPFORCE's INERTIA FORCE
            with open(self.file_name, mode='r', encoding='utf-8') as f:
                lines = f.readlines()
        except FileNotFoundError as e:
            raise ReadFail(str(e))
        except UnicodeDecodeError:
            # Unicode fails on older versions of Mystran that use some 
            # other encoding for U-dot-dot.
            # We can't always use latin1 because it treats the unicode U-dot-dot
            # as two characters and misaligns the line.
            with open(self.file_name, mode='r', encoding="latin1") as f:
                lines = f.readlines()

        if len(lines) > 2 and lines[2].startswith(" MYSTRAN"):
            self.parsed_f06 =  self._read_mystran(lines)
        elif len(lines) > 17 and "* *      M S C   N a s t r a n      * *" in lines[17]:
            self.parsed_f06 =  self._read_msc(lines)
        else:
            raise ReadFail(f"ERROR reading {self.file_name}: Can't identify format.")

    @staticmethod
    def ensure_path(current_node, path):
        for node in path:
            if not node in current_node:
                current_node[node] = {}
            current_node = current_node[node]
        return current_node


    @staticmethod
    def set(node, key, value):
        node[key] = value


    @staticmethod
    def number(line, start, length, blank_is_inf=False):
        segment = line[start - 1:start - 1 + length].strip()
        if blank_is_inf and segment == "":
            return float('inf')
        try:
            return float(segment)
        except Exception as e:
            # It might be a 3-digit exponent without the "e" like:
            #
            #           2.714527-111
            # or
            #           2.714527+111
            segment = segment[:-4] + "E" + segment[-4:]
            return float(segment)


    def _read_mystran(self, lines):

        root = {}
        line_no = 0
        previous_prefix = None

        def get_next_line():
            nonlocal line_no
            if line_no >= len(lines):
                raise ReadFail(f"ERROR: Unexpected end of file at line {line_no} of {self.file_name}")
            line = lines[line_no]
            line_no += 1
            return line

        def peek_line_delta(delta):
            return lines[line_no - 1 + delta]

        def subcase_mode():
            # Determine the subcase and mode that the block we're at belongs to.
            #
            # Search backwards not more than up to 8 non-blank lines and skipping blank lines
            # Non-blank lines are typically TITLE, SUBTITLE, LABEL.
            # Sometimes TITLE appears 2-6 times due to a bug in Mystran v18.0.0-.
            # Blank lines are sometimes a lot due to a possible Mystran bug.
            nonlocal previous_prefix
            non_blanks = 0
            delta = -2
            while True:
                line = peek_line_delta(delta)

                if line.startswith(" OUTPUT FOR SUBCASE"):
                    subcase = int(self.number(line, 21, 8))
                    previous_prefix = ["SC", str(subcase)]
                    return previous_prefix

                if line.startswith(" OUTPUT FOR EIGENVECTOR"):
                    mode = int(self.number(line, 25, 8))
                    # Decide what subcase this mode is in.
                    prev_line = peek_line_delta(delta - 1)
                    if prev_line.startswith(" OUTPUT FOR SUBCASE"):
                        # v18.1.0+ with a subcase defined in the deck shows subcase number for each eigenvector block.
                        # v18.0.0- Impossible
                        subcase = int(self.number(prev_line, 21, 8))
                    else:
                        # v18.1.0+ without a subcase defined. Modes are always in SC1.
                        # v18.0.0- modes are always in SC1 for normal modes or SC2 for buckling modes.
                        if buckling is None:
                            # v18.1.0+ Impossible but this shows we don't need to use the buckling variable.
                            # v18.0.0- Impossible.
                            subcase = 1
                        elif buckling:
                            # v18.1.0+ Impossible because subcases are always defined for buckling.
                            # v18.0.0- Buckling eigenvectors are in always in subcase 2.
                            subcase = 2
                        else:
                            # v18.1.0+ Typical for normal modes with no subcase defined.
                            # v18.0.0- Normal modes eigenvectors are in subcase 1
                            subcase = 1

                    previous_prefix = ["SC", str(subcase), "MODE", str(mode)]

                    return previous_prefix

                if line.strip() != "":
                    non_blanks += 1
                if non_blanks > 8:
                    return None
                delta -= 1        

        major_version = None
        buckling = None
      
        while line_no < len(lines):
            line = get_next_line()

            if line.startswith(" MYSTRAN Version"):
                major_version = int(line[17:25].split(".")[0])
            
            elif "D I S P L A C E M E N T S" in line \
              or "E I G E N V E C T O R" in line \
              or "S P C   F O R C E S" in line \
              or "M P C   F O R C E S" in line \
              or "A P P L I E D    F O R C E S" in line:
                if "D I S P L A C E M E N T S" in line:     block_name = "DISPLACEMENTS"
                if "E I G E N V E C T O R" in line:         block_name = "EIGENVECTOR"
                if "S P C   F O R C E S" in line:           block_name = "SPCFORCES"
                if "M P C   F O R C E S" in line:           block_name = "MPCFORCES"
                if "A P P L I E D    F O R C E S" in line:  block_name = "APPLIEDFORCES"
                prefix = subcase_mode()
                gids_node = self.ensure_path(root, prefix + [block_name, "GID"])
                get_next_line()
                line = get_next_line()
                if "(including equivalent thermal loads)" in line:
                    get_next_line()
                get_next_line()
                had_blank_line = False
                while True:
                    line = get_next_line()
                    if len(line) >= 27 and line[0:15].strip().isdigit():
                        # This line has data.
                        had_blank_line = False
                        gid = int(self.number(line, 8, 8))
                        gid_node = self.ensure_path(gids_node, [str(gid)])
                        self.set(gid_node, "TX", self.number(line, 26, 13))
                        self.set(gid_node, "TY", self.number(line, 40, 13))
                        self.set(gid_node, "TZ", self.number(line, 54, 13))
                        self.set(gid_node, "RX", self.number(line, 68, 13))
                        self.set(gid_node, "RY", self.number(line, 82, 13))
                        self.set(gid_node, "RZ", self.number(line, 96, 13))
                    elif line.startswith(" *INFORMATION:"):
                        # It can be this:
                        # *INFORMATION: COORD SYSTEM       -2 FOR STRESS TRANSFORMATION IS UNDEFINED. LOCAL ELEMENT COORD SYSTEM WILL BE USED
                        had_blank_line = False
                        break
                    elif had_blank_line:
                        # A non-data line after a blank line is past the end of the block.
                        break
                    elif len(line.strip()) == 0:
                        # Skip blank line at GID gaps.
                        had_blank_line = True
                        continue
                    else:
                        # Not data and not blank. Might be ---
                        break

            elif "G R I D   P O I N T   F O R C E   B A L A N C E" in line \
            and not "C B   G R I D   P O I N T   F O R C E   B A L A N C E   O T M" in line:
                prefix = subcase_mode()
                if prefix is None:
                    if previous_prefix is not None:
                        # Some v15 files (SS-BAR-10-BUCKLING-CF-LOAD-LAN-3D.F06) have no subcase or
                        # mode for GPFORCE. Use the subcase or mode that was last read, from the 
                        # previous block.
                        prefix = previous_prefix
                    else:
                        # Don't know what to do.
                        raise ReadFail(f"ERROR reading {self.file_name}: No previous block with subcase or eigenvector before line {line_no}.")
                get_next_line()
                get_next_line()
                gids_node = self.ensure_path(root, prefix + ["GPFORCE","GID"])
                # Read grid point sub-blocks
                while True:
                    line = get_next_line()
                    if "FORCE BALANCE FOR GRID POINT" in line:
                        gid = int(self.number(line, 62, 8))
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        gid_node = self.ensure_path(gids_node, [str(gid)])
                        # Rows in sub-block
                        while True:
                            line = get_next_line()
                            if "APPLIED FORCE" in line:
                                force_node = self.ensure_path(gid_node, ["APPLIED"])
                            elif "SPC FORCE" in line:
                                force_node = self.ensure_path(gid_node, ["SPC"])
                            elif "MPC FORCE" in line:
                                force_node = self.ensure_path(gid_node, ["MPC"])
                            elif "MINUS EQUIV THERM LOAD" in line:
                                force_node = self.ensure_path(gid_node, ["THERMAL"])
                            elif "INERTIA FORCE" in line:
                                force_node = self.ensure_path(gid_node, ["INERTIA"])
                            elif "ELEM" in line:
                                eid = int(self.number(line, 17, 8))
                                eids_node = self.ensure_path(gid_node, ["EID"])
                                force_node = self.ensure_path(eids_node, [str(eid)])
                            else:
                                # End of sub-block
                                break
                            self.set(force_node, "TX", self.number(line, 26, 13))
                            self.set(force_node, "TY", self.number(line, 40, 13))
                            self.set(force_node, "TZ", self.number(line, 54, 13))
                            self.set(force_node, "RX", self.number(line, 68, 13))
                            self.set(force_node, "RY", self.number(line, 82, 13))
                            self.set(force_node, "RZ", self.number(line, 96, 13))

                    elif line.startswith(" TOTALS"):
                        continue
                    elif line.startswith(" (should all be 0)"):
                        continue
                    elif line.strip() == "":
                        continue
                    else:
                        # End of block
                        break

            elif "E L E M E N T   S T R E S S E S   I N   M A T E R I A L   C O O R D I N A T E   S Y S T E M" in line:
                prefix = subcase_mode()
                if prefix is not None:
                    line = get_next_line()
                    if "F O R   E L E M E N T   T Y P E   H E X A" in line \
                    or "F O R   E L E M E N T   T Y P E   P E N T A" in line \
                    or "F O R   E L E M E N T   T Y P E   T E T R A" in line:
                        eids_node = self.ensure_path(root, prefix + ["SOLIDSTRESSES","EID"])
                        get_next_line()
                        get_next_line()
                        corner = None
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---") or len(line.strip()) == 0:
                                break
                            if line[11:11+6] == "CENTER":
                                eid = int(self.number(line, 2,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                                corner =0
                                corner_gid = None
                            elif line[11:11+3] == "GRD":
                                corner += 1
                                corner_gid = int(self.number(line, 15, 8))
                            corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                            if corner_gid is not None:
                                self.set(corner_node, "GID", corner_gid)
                            self.set(corner_node, "XX", self.number(line, 29, 13))
                            self.set(corner_node, "YY", self.number(line, 43, 13))
                            self.set(corner_node, "ZZ", self.number(line, 57, 13))
                            self.set(corner_node, "XY", self.number(line, 71, 13))
                            self.set(corner_node, "YZ", self.number(line, 85, 13))
                            self.set(corner_node, "ZX", self.number(line, 99, 13))
                            self.set(corner_node, "VONMISES", self.number(line, 113, 13)) # todo might be max. shear. Read column header to decide.

            elif "E L E M E N T   S T R E S S E S   I N   L O C A L   E L E M E N T   C O O R D I N A T E   S Y S T E M" in line:
                prefix = subcase_mode()
                if prefix is None:
                    raise ReadFail(f"ERROR reading {self.file_name}: No subcase or eigenvector found before line {line_no}")
                line = get_next_line()
                if "F O R   E L E M E N T   T Y P E   Q U A D 4" in line \
                or "F O R   E L E M E N T   T Y P E   Q U A D 8" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRESSES","EID"])
                    get_next_line()
                    line = get_next_line()
                    if line[109:109+8] == "Shear-XY":
                        failure = "MAXSHEAR"
                    else:
                        failure = "VONMISES"
                    get_next_line()
                    corner = None
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---"):
                            break
                        if line[11:11+6] == "CENTER":
                            eid = int(self.number(line, 2,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            corner = 0
                            corner_gid = None
                        elif line[11:11+3] == "GRD":
                            corner += 1
                            corner_gid = int(self.number(line, 15, 8))
                        else:
                            # Skip the blank lines between corners
                            continue
                        corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                        if corner_gid is not None:
                            self.set(corner_node, "GID", corner_gid)
                        self.set(corner_node, "ZX", self.number(line, 121, 12))
                        self.set(corner_node, "YZ", self.number(line, 134, 12))
                        z1_node = self.ensure_path(corner_node, ["Z1"])
                        self.set(z1_node, "XX", self.number(line, 35, 12))
                        self.set(z1_node, "YY", self.number(line, 48, 12))
                        self.set(z1_node, "XY", self.number(line, 61, 12))
                        self.set(z1_node, "PRINCIPALANGLE", self.number(line, 75, 6))
                        self.set(z1_node, "MAJOR", self.number(line, 82, 12))
                        self.set(z1_node, "MINOR", self.number(line, 95, 12))
                        self.set(z1_node, failure, self.number(line, 108, 12))
                        line = get_next_line()
                        z2_node = self.ensure_path(corner_node, ["Z2"])
                        self.set(z2_node, "XX", self.number(line, 35, 12))
                        self.set(z2_node, "YY", self.number(line, 48, 12))
                        self.set(z2_node, "XY", self.number(line, 61, 12))
                        self.set(z2_node, "PRINCIPALANGLE", self.number(line, 75, 6))
                        self.set(z2_node, "MAJOR", self.number(line, 82, 12))
                        self.set(z2_node, "MINOR", self.number(line, 95, 12))
                        self.set(z2_node, failure, self.number(line, 108, 12))

                elif "F O R   E L E M E N T   T Y P E   T R I A 3" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRESSES","EID"])
                    get_next_line()
                    line = get_next_line()
                    if line[113:113+8] == "Shear-XY":
                        failure = "MAXSHEAR"
                    else:
                        failure = "VONMISES"
                    get_next_line()
                    corner = None
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---"):
                            break
                        if line[13:13+8] == "Anywhere":
                            eid = int(self.number(line, 2,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            corner =0
                            corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                            self.set(corner_node, "ZX", self.number(line, 125, 12))
                            self.set(corner_node, "YZ", self.number(line, 138, 12))
                            z1_node = self.ensure_path(corner_node, ["Z1"])
                            self.set(z1_node, "XX", self.number(line, 38, 12))
                            self.set(z1_node, "YY", self.number(line, 51, 12))
                            self.set(z1_node, "XY", self.number(line, 64, 12))
                            self.set(z1_node, "PRINCIPALANGLE", self.number(line, 78, 7))
                            self.set(z1_node, "MAJOR", self.number(line, 86, 12))
                            self.set(z1_node, "MINOR", self.number(line, 99, 12))
                            self.set(z1_node, failure, self.number(line, 112, 12))
                            line = get_next_line()
                            z2_node = self.ensure_path(corner_node, ["Z2"])
                            self.set(z2_node, "XX", self.number(line, 38, 12))
                            self.set(z2_node, "YY", self.number(line, 51, 12))
                            self.set(z2_node, "XY", self.number(line, 64, 12))
                            self.set(z2_node, "PRINCIPALANGLE", self.number(line, 78, 7))
                            self.set(z2_node, "MAJOR", self.number(line, 86, 12))
                            self.set(z2_node, "MINOR", self.number(line, 99, 12))
                            self.set(z2_node, failure, self.number(line, 112, 12))

                elif "F O R   E L E M E N T   T Y P E   B U S H" in line:
                    eids_node = self.ensure_path(root, prefix + ["BUSHSTRESSES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        eid = int(self.number(line, 20, 8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        self.set(eid_node, "TX", self.number(line, 29, 13))
                        self.set(eid_node, "TY", self.number(line, 43, 13))
                        self.set(eid_node, "TZ", self.number(line, 57, 13))
                        self.set(eid_node, "RX", self.number(line, 71, 13))
                        self.set(eid_node, "RY", self.number(line, 85, 13))
                        self.set(eid_node, "RZ", self.number(line, 99, 13))

                elif "F O R   E L E M E N T   T Y P E   B A R" in line:
                    eids_node = self.ensure_path(root, prefix + ["BARSTRESSES","EID"])
                    get_next_line()
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---"):
                            break
                        elif len(line.strip()) == 0:
                            continue # Skip blank lines
                        else:
                            eid = int(self.number(line, 2,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "SA1", self.number(line, 11, 13))
                            self.set(eid_node, "SA2", self.number(line, 25, 13))
                            self.set(eid_node, "SA3", self.number(line, 39, 13))
                            self.set(eid_node, "SA4", self.number(line, 53, 13))
                            self.set(eid_node, "AXIAL", self.number(line, 67, 13))
                            line = get_next_line()
                            self.set(eid_node, "SB1", self.number(line, 11, 13))
                            self.set(eid_node, "SB2", self.number(line, 25, 13))
                            self.set(eid_node, "SB3", self.number(line, 39, 13))
                            self.set(eid_node, "SB4", self.number(line, 53, 13))

                elif "F O R   E L E M E N T   T Y P E   R O D" in line:
                    eids_node = self.ensure_path(root, prefix + ["RODSTRESSES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---"):
                            break
                        else:
                            eid = int(self.number(line, 2,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "AXIAL", self.number(line, 11, 13))
                            self.set(eid_node, "AXIALSAFETY", self.number(line, 25, 9, blank_is_inf=True))
                            self.set(eid_node, "TORSIONAL", self.number(line, 36, 13))
                            self.set(eid_node, "TORSIONALSAFETY", self.number(line, 50, 9, blank_is_inf=True))
                            if len(line) > 67 and line[66] != " ":
                                eid = int(self.number(line, 60,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                                self.set(eid_node, "AXIAL", self.number(line, 69, 13))
                                self.set(eid_node, "AXIALSAFETY", self.number(line, 83, 9, blank_is_inf=True))
                                self.set(eid_node, "TORSIONAL", self.number(line, 94, 13))
                                self.set(eid_node, "TORSIONALSAFETY", self.number(line, 108, 9, blank_is_inf=True))

                elif "F O R   E L E M E N T   T Y P E   E L A S 1" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 2" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 3" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 4" in line:
                    eids_node = self.ensure_path(root, prefix + ["ELASSTRESSES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        else:
                            for element_col in range(5):
                                start = element_col * 23
                                if len(line) > start+9 and line[start+8] != " ":
                                    eid = int(self.number(line, start + 2,8))
                                    self.set(eids_node, str(eid), self.number(line, start + 11, 13))


            elif "S T R E S S E S   I N   L A Y E R E D   C O M P O S I T E   E L E M E N T S" in line:
                prefix = subcase_mode()
                if prefix is not None:
                    get_next_line()
                    get_next_line()
                    get_next_line()
                    line = get_next_line()
                    if "F O R   E L E M E N T   T Y P E   Q U A D 4" in line \
                    or "F O R   E L E M E N T   T Y P E   Q U A D 8" in line \
                    or "F O R   E L E M E N T   T Y P E   T R I A 3" in line:
                        eids_node = self.ensure_path(root, prefix + ["COMPOSITESTRESSES","EID"])
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        get_next_line()
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---"):
                                break
                            if line[1:1+8].strip() != "":
                                eid = int(self.number(line, 2,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                            elif line.strip() == "":
                                # Skip the blank lines between elements
                                continue
                            ply_num = int(self.number(line, 11,5))
                            ply_node = self.ensure_path(eid_node, ["PLY", str(ply_num)])
                            self.set(ply_node, "11", self.number(line, 17, 12))
                            self.set(ply_node, "22", self.number(line, 30, 12))
                            self.set(ply_node, "12", self.number(line, 43, 12))
                            self.set(ply_node, "13", self.number(line, 59, 12))
                            self.set(ply_node, "23", self.number(line, 73, 12))

            elif "E L E M E N T   S T R A I N S   I N   M A T E R I A L   C O O R D I N A T E   S Y S T E M" in line:
                prefix = subcase_mode()
                if prefix is not None:
                    line = get_next_line()
                    if "F O R   E L E M E N T   T Y P E   H E X A" in line \
                    or "F O R   E L E M E N T   T Y P E   P E N T A" in line \
                    or "F O R   E L E M E N T   T Y P E   T E T R A" in line:
                        eids_node = self.ensure_path(root, prefix + ["SOLIDSTRAINS","EID"])
                        get_next_line()
                        get_next_line()
                        corner = None
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---") or len(line.strip()) == 0:
                                break
                            if line[11:11+6] == "CENTER":
                                eid = int(self.number(line, 2,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                                corner = 0
                                corner_gid = None
                            elif line[11:11+3] == "GRD":
                                corner += 1
                                corner_gid = int(self.number(line, 15, 8))
                            corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                            if corner_gid is not None:
                                self.set(corner_node, "GID", corner_gid)
                            self.set(corner_node, "XX", self.number(line, 29, 13))
                            self.set(corner_node, "YY", self.number(line, 43, 13))
                            self.set(corner_node, "ZZ", self.number(line, 57, 13))
                            self.set(corner_node, "XY", self.number(line, 71, 13))
                            self.set(corner_node, "YZ", self.number(line, 85, 13))
                            self.set(corner_node, "ZX", self.number(line, 99, 13))
                            self.set(corner_node, "VONMISES", self.number(line, 113, 13)) # todo might be max. shear. Read column header to decide.

            elif "E L E M E N T   S T R A I N S   I N   L O C A L   E L E M E N T   C O O R D I N A T E   S Y S T E M" in line:
                prefix = subcase_mode()
                if prefix is not None:
                    line = get_next_line()
                    if "F O R   E L E M E N T   T Y P E   Q U A D 4" in line \
                    or "F O R   E L E M E N T   T Y P E   Q U A D 8" in line:
                        eids_node = self.ensure_path(root, prefix + ["SHELLSTRAINS","EID"])
                        get_next_line()
                        line = get_next_line()
                        if line[24:24+8] == "Distance":
                            row_1_name = "Z1"
                            row_2_name = "Z2"
                        elif line[24:24+9] == "Curvature":
                            row_1_name = "MEMB"
                            row_2_name = "CURV"
                        else:
                            # Ignore the block if it has an unknown header
                            continue
                        if line[109:109+8] == "Shear-XY":
                            failure = "MAXSHEAR"
                        else:
                            failure = "VONMISES"
                        get_next_line()
                        corner = None
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---"):
                                break
                            if line[11:11+6] == "CENTER":
                                eid = int(self.number(line, 2,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                                corner = 0
                                corner_gid = None
                            elif line[11:11+3] == "GRD":
                                corner += 1
                                corner_gid = int(self.number(line, 15, 8))
                            else:
                                # Skip the blank lines between corners
                                continue
                            corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                            if corner_gid is not None:
                                self.set(corner_node, "GID", corner_gid)
                            self.set(corner_node, "ZX", self.number(line, 121, 12))
                            self.set(corner_node, "YZ", self.number(line, 134, 12))
                            z1_node = self.ensure_path(corner_node, [row_1_name])
                            self.set(z1_node, "XX", self.number(line, 35, 12))
                            self.set(z1_node, "YY", self.number(line, 48, 12))
                            self.set(z1_node, "XY", self.number(line, 61, 12))
                            self.set(z1_node, "PRINCIPALANGLE", self.number(line, 75, 6))
                            self.set(z1_node, "MAJOR", self.number(line, 82, 12))
                            self.set(z1_node, "MINOR", self.number(line, 95, 12))
                            self.set(z1_node, failure, self.number(line, 108, 12))
                            line = get_next_line()
                            z2_node = self.ensure_path(corner_node, [row_2_name])
                            self.set(z2_node, "XX", self.number(line, 35, 12))
                            self.set(z2_node, "YY", self.number(line, 48, 12))
                            self.set(z2_node, "XY", self.number(line, 61, 12))
                            self.set(z2_node, "PRINCIPALANGLE", self.number(line, 75, 6))
                            self.set(z2_node, "MAJOR", self.number(line, 82, 12))
                            self.set(z2_node, "MINOR", self.number(line, 95, 12))
                            self.set(z2_node, failure, self.number(line, 108, 12))

                    elif "F O R   E L E M E N T   T Y P E   T R I A 3" in line:
                        eids_node = self.ensure_path(root, prefix + ["SHELLSTRAINS","EID"])
                        get_next_line()
                        line = get_next_line()
                        if line[26:26+8] == "Distance":
                            row_1_name = "Z1"
                            row_2_name = "Z2"
                        elif line[26:26+9] == "Curvature":
                            row_1_name = "MEMB"
                            row_2_name = "CURV"
                        else:
                            # Ignore the block if it has an unknown header
                            continue
                        if line[113:113+8] == "Shear-XY":
                            failure = "MAXSHEAR"
                        else:
                            failure = "VONMISES"
                        get_next_line()
                        corner = None
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---"):
                                break
                            if line[13:13+8] == "Anywhere":
                                eid = int(self.number(line, 2,8))
                                eid_node = self.ensure_path(eids_node, [str(eid)])
                                corner =0
                                corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                                self.set(corner_node, "ZX", self.number(line, 125, 12))
                                self.set(corner_node, "YZ", self.number(line, 138, 12))
                                z1_node = self.ensure_path(corner_node, [row_1_name])
                                self.set(z1_node, "XX", self.number(line, 38, 12))
                                self.set(z1_node, "YY", self.number(line, 51, 12))
                                self.set(z1_node, "XY", self.number(line, 64, 12))
                                self.set(z1_node, "PRINCIPALANGLE", self.number(line, 78, 7))
                                self.set(z1_node, "MAJOR", self.number(line, 86, 12))
                                self.set(z1_node, "MINOR", self.number(line, 99, 12))
                                self.set(z1_node, failure, self.number(line, 112, 12))
                                line = get_next_line()
                                z2_node = self.ensure_path(corner_node, [row_2_name])
                                self.set(z2_node, "XX", self.number(line, 38, 12))
                                self.set(z2_node, "YY", self.number(line, 51, 12))
                                self.set(z2_node, "XY", self.number(line, 64, 12))
                                self.set(z2_node, "PRINCIPALANGLE", self.number(line, 78, 7))
                                self.set(z2_node, "MAJOR", self.number(line, 86, 12))
                                self.set(z2_node, "MINOR", self.number(line, 99, 12))
                                self.set(z2_node, failure, self.number(line, 112, 12))

                    elif "F O R   E L E M E N T   T Y P E   B U S H" in line:
                        eids_node = self.ensure_path(root, prefix + ["BUSHSTRAINS","EID"])
                        get_next_line()
                        get_next_line()
                        while True:
                            line = get_next_line()
                            if line.strip().startswith("---") or len(line.strip()) == 0:
                                break
                            eid = int(self.number(line, 20, 8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "TX", self.number(line, 29, 13))
                            self.set(eid_node, "TY", self.number(line, 43, 13))
                            self.set(eid_node, "TZ", self.number(line, 57, 13))
                            self.set(eid_node, "RX", self.number(line, 71, 13))
                            self.set(eid_node, "RY", self.number(line, 85, 13))
                            self.set(eid_node, "RZ", self.number(line, 99, 13))

            elif "E L E M E N T   E N G I N E E R I N G   F O R C E S" in line:
                prefix = subcase_mode()
                if prefix is None:
                    raise ReadFail(f"ERROR reading {self.file_name}: No subcase or eigenvector found before line {line_no}")
                line = get_next_line()
                if "F O R   E L E M E N T   T Y P E   Q U A D 4" in line \
                or "F O R   E L E M E N T   T Y P E   Q U A D 8" in line \
                or "F O R   E L E M E N T   T Y P E   T R I A 3" in line:
                    thin_k_type = "Q U A D 4 K" in line or "T R I A 3 K" in line
                    eids_node = self.ensure_path(root, prefix + ["SHELLFORCES","EID"])
                    get_next_line()
                    get_next_line()
                    get_next_line()
                    corner = None
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        if line[11:11+3] == "GRD":
                            corner += 1
                            corner_gid = int(self.number(line, 15, 8))
                        else:
                            if "CENTER" in line:
                                # Some elements (QUAD8) say "CENTER"
                                eid = int(self.number(line, 2,8))
                            else:
                                # Some elements (QUAD4, TRIA3) don't say "CENTER" and older Mystran put EID futher right
                                eid = int(self.number(line, 2,23))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            corner = 0
                            corner_gid = None
                        corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                        if corner_gid is not None:
                            self.set(corner_node, "GID", corner_gid)
                        self.set(corner_node, "NXX", self.number(line, 26, 13))
                        self.set(corner_node, "NYY", self.number(line, 40, 13))
                        self.set(corner_node, "NXY", self.number(line, 54, 13))
                        self.set(corner_node, "MXX", self.number(line, 68, 13))
                        self.set(corner_node, "MYY", self.number(line, 82, 13))
                        self.set(corner_node, "MXY", self.number(line, 96, 13))
                        if not thin_k_type:
                            self.set(corner_node, "QX", self.number(line, 110, 13))
                            self.set(corner_node, "QY", self.number(line, 124, 13))

                if "F O R   E L E M E N T   T Y P E   B U S H" in line:
                    eids_node = self.ensure_path(root, prefix + ["BUSHFORCES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        eid = int(self.number(line, 17, 8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        self.set(eid_node, "TX", self.number(line, 26, 13))
                        self.set(eid_node, "TY", self.number(line, 40, 13))
                        self.set(eid_node, "TZ", self.number(line, 54, 13))
                        self.set(eid_node, "RX", self.number(line, 68, 13))
                        self.set(eid_node, "RY", self.number(line, 82, 13))
                        self.set(eid_node, "RZ", self.number(line, 96, 13))

                if "F O R   E L E M E N T   T Y P E   B A R" in line:
                    eids_node = self.ensure_path(root, prefix + ["BARFORCES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("OUTPUT FOR"):
                            # Mystran v15- would sometimes include this spurious line.
                            continue
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        if major_version <= 12:
                            # Different indenting
                            eid = int(self.number(line, 2,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "MA1", self.number(line, 11, 13))
                            self.set(eid_node, "MA2", self.number(line, 25, 13))
                            self.set(eid_node, "MB1", self.number(line, 39, 13))
                            self.set(eid_node, "MB2", self.number(line, 53, 13))
                            self.set(eid_node, "S1", self.number(line, 67, 13))
                            self.set(eid_node, "S2", self.number(line, 81, 13))
                            self.set(eid_node, "AXIAL", self.number(line, 95, 13))
                            self.set(eid_node, "TORQUE", self.number(line, 109, 13))
                        else:
                            eid = int(self.number(line, 17, 8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "MA1", self.number(line, 26, 13))
                            self.set(eid_node, "MA2", self.number(line, 40, 13))
                            self.set(eid_node, "MB1", self.number(line, 54, 13))
                            self.set(eid_node, "MB2", self.number(line, 68, 13))
                            self.set(eid_node, "S1", self.number(line, 82, 13))
                            self.set(eid_node, "S2", self.number(line, 96, 13))
                            self.set(eid_node, "AXIAL", self.number(line, 110, 13))
                            self.set(eid_node, "TORQUE", self.number(line, 124, 13))

                if "F O R   E L E M E N T   T Y P E   R O D" in line:
                    eids_node = self.ensure_path(root, prefix + ["RODFORCES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---"):
                            break
                        eid = int(self.number(line, 17, 8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        self.set(eid_node, "AXIAL", self.number(line, 26, 13))
                        self.set(eid_node, "TORQUE", self.number(line, 40, 13))
                        if len(line) > 60 and line[59] != " ":
                            eid = int(self.number(line, 53,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "AXIAL", self.number(line, 62, 13))
                            self.set(eid_node, "TORQUE", self.number(line, 76, 13))
                        if len(line) > 96 and line[95] != " ":
                            eid = int(self.number(line, 89,8))
                            eid_node = self.ensure_path(eids_node, [str(eid)])
                            self.set(eid_node, "AXIAL", self.number(line, 98, 13))
                            self.set(eid_node, "TORQUE", self.number(line, 112, 13))

                elif "F O R   E L E M E N T   T Y P E   E L A S 1" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 2" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 3" in line \
                or   "F O R   E L E M E N T   T Y P E   E L A S 4" in line:
                    eids_node = self.ensure_path(root, prefix + ["ELASFORCES","EID"])
                    get_next_line()
                    get_next_line()
                    while True:
                        line = get_next_line()
                        if line.strip().startswith("---") or len(line.strip()) == 0:
                            break
                        else:
                            for element_col in range(5):
                                start = 16 + element_col * 22
                                if len(line) > start+8 and line[start+7] != " ":
                                    eid = int(self.number(line, start+1, 8))
                                    self.set(eids_node, str(eid), self.number(line, start + 10, 13))


            elif "R E A L   E I G E N V A L U E S" in line:
                prefix = subcase_mode()
                line = get_next_line()
                buckling = "buckling" in line
                get_next_line()
                get_next_line()
                if buckling:
                    get_next_line()
                    get_next_line()
                if prefix is None:
                    # v18.0.0- Subcase depends on if it's buckling or normal modes.
                    # v18.1.0+ If no subcases are defined, it falls back to this which will be SC1.
                   prefix = ["SC", "2"] if buckling else ["SC", "1"]
                modes_node = self.ensure_path(root, prefix + ["REALEIGENVALUES","MODE"])
                while True:
                    line = get_next_line()
                    if line.strip().startswith("---") or len(line.strip()) == 0:
                        break
                    if buckling:
                        mode = int(self.number(line, 39, 8))
                        mode_node = self.ensure_path(modes_node, [str(mode)])
                        eigenvalue = self.number(line, 62, 13)
                        self.set(mode_node, "EIGENVALUE", eigenvalue)
                    else:
                        mode = int(self.number(line, 2, 8))
                        mode_node = self.ensure_path(modes_node, [str(mode)])
                        eigenvalue = self.number(line, 25, 13)
                        cycles = self.number(line, 65, 13)
                        self.set(mode_node, "EIGENVALUE", eigenvalue)
                        self.set(mode_node, "CYCLES", cycles)
                    

        return root
 
    def _read_msc(self, lines):

        def get_next_line():
            nonlocal line_no
            if line_no >= len(lines):
                raise ReadFail(f"ERROR: Unexpected end of file at line {line_no} of {self.file_name}")
            line = lines[line_no]
            line_no += 1
            return line

        def peek_line_delta(delta):
            return lines[line_no - 1 + delta]

        def subcase_mode(mode=None):
            # Determine the subcase that the block we're at belongs to.
            # Search back up to 4 lines for a line with "SUBCASE" at column 110 (1-based).
            subcase = 1  # Default is 1 if no subcase is specified.
            delta = -2
            while delta >= -4:
                line = peek_line_delta(delta)
                if len(line) > 116 and line[109:116] == "SUBCASE":
                    subcase = int(self.number(line, 118, 8))
                    break
                delta -= 1
            if mode is None:
                return ["SC", str(subcase)]
            else:
                return ["SC", str(subcase), "MODE", str(mode)]

        def is_mode_block():
            # Returns True if the current block header is preceded by "EIGENVALUE = ..."
            # within the last 3 lines, indicating it belongs to an eigenvector mode and
            # should NOT be stored as a regular subcase result.
            # delta=-1: EIGENVALUE immediately precedes the header (e.g. SPCFORCES)
            # delta=-2: EIGENVALUE is 2 lines back with CYCLES line in between (e.g. element strain energies)
            # delta=-2: EIGENVALUE is 2 lines back with blank line in between (e.g. QUAD4 forces)
            # delta=-3: EIGENVALUE is 3 lines back with CYCLES + MODE lines in between (e.g. GPFORCE)
            for delta in range(-1, -4, -1):
                idx = line_no - 1 + delta
                if idx < 0:
                    break
                if lines[idx].startswith("      EIGENVALUE = "):
                    return True
            return False

        def is_data_line(line):
            # Data lines start with a space then a positive integer GID/mode number.
            return len(line) >= 14 and line[0] == " " and line[0:14].strip().isdigit()

        def read_gid_block(gids_node):
            # Skip the blank line and "POINT ID.   TYPE ..." column header that
            # follow a displacement/load/SPC-force block header.
            get_next_line()  # blank
            get_next_line()  # "POINT ID.   TYPE   T1 ..." header
            while True:
                line = get_next_line()
                if is_data_line(line):
                    gid = int(self.number(line, 7, 8))
                    gid_node = self.ensure_path(gids_node, [str(gid)])
                    self.set(gid_node, "TX", self.number(line, 27, 13))
                    self.set(gid_node, "TY", self.number(line, 42, 13))
                    self.set(gid_node, "TZ", self.number(line, 57, 13))
                    self.set(gid_node, "RX", self.number(line, 72, 13))
                    self.set(gid_node, "RY", self.number(line, 87, 13))
                    self.set(gid_node, "RZ", self.number(line, 102, 13))
                else:
                    # End of block for this page (page break, blank, or other header).
                    break

        def read_gpforce_block(gids_node):
            # Skip blank line and "POINT-ID    ELEMENT-ID     SOURCE ..." column header.
            get_next_line()  # blank
            get_next_line()  # "POINT-ID    ELEMENT-ID ..." header
            while True:
                line = get_next_line()
                if len(line) < 43 or line[0] == "1":
                    # Page break or too-short line — end of block.
                    break
                if line.startswith(" ***"):
                    # Something like " *** USER INFORMATION MESSAGE 4114 (OUTPX2)"
                    # Which is followed by more text. Abandon the block becuase
                    # it's hard to know if/how to find the end of it to restart.
                    break
                gid_field = line[1:13].strip()
                eid_field = line[13:27].strip()
                src = line[27:42].strip()
                if src == "":
                    # Blank source — not a data row.
                    break
                if src == "*TOTALS*":
                    # Balance check row — skip.
                    continue
                gid_node = self.ensure_path(gids_node, [gid_field])
                force_node = None
                if src == "F-OF-SPC":
                    force_node = self.ensure_path(gid_node, ["SPC"])
                elif src == "F-OF-MPC":
                    force_node = self.ensure_path(gid_node, ["MPC"])
                elif src == "APP-LOAD":
                    force_node = self.ensure_path(gid_node, ["APPLIED"])
                elif src == "THERMAL":
                    force_node = self.ensure_path(gid_node, ["THERMAL"])
                elif eid_field.isdigit():
                    # Element contribution row (e.g. "BAR", "QUAD4", etc.)
                    eids_node = self.ensure_path(gid_node, ["EID"])
                    force_node = self.ensure_path(eids_node, [eid_field])
                if force_node is not None:
                    self.set(force_node, "TX", self.number(line, 44, 13))
                    self.set(force_node, "TY", self.number(line, 59, 13))
                    self.set(force_node, "TZ", self.number(line, 74, 13))
                    self.set(force_node, "RX", self.number(line, 89, 13))
                    self.set(force_node, "RY", self.number(line, 104, 13))
                    self.set(force_node, "RZ", self.number(line, 119, 13))

        root = {}
        line_no = 0
        corner = None
        eid_node = None

        while line_no < len(lines):
            line = get_next_line()
            prefix = None # Prevent accidental reuse

            if "D I S P L A C E M E N T   V E C T O R" in line:
                prefix = subcase_mode()
                gids_node = self.ensure_path(root, prefix + ["DISPLACEMENTS", "GID"])
                read_gid_block(gids_node)

            elif "R E A L   E I G E N V E C T O R   N O ." in line:
                # Extract mode number from the header line itself.
                mode = int(self.number(line, 84, 8))
                # Subcase comes from the label line two lines back.
                prefix = subcase_mode(mode=mode)
                gids_node = self.ensure_path(root, prefix + ["EIGENVECTOR", "GID"])
                read_gid_block(gids_node)

            elif "F O R C E S   O F   S I N G L E - P O I N T   C O N S T R A I N T" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                gids_node = self.ensure_path(root, prefix + ["SPCFORCES", "GID"])
                read_gid_block(gids_node)

            elif "F O R C E S   O F   M U L T I P O I N T   C O N S T R A I N T" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                gids_node = self.ensure_path(root, prefix + ["MPCFORCES", "GID"])
                read_gid_block(gids_node)

            elif "L O A D   V E C T O R" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                gids_node = self.ensure_path(root, prefix + ["APPLIEDFORCES", "GID"])
                read_gid_block(gids_node)

            elif "G R I D   P O I N T   F O R C E   B A L A N C E" in line:
                prefix = subcase_mode()
                if is_mode_block():
                    # GPFORCE in a mode lists the mode number before the header, unlike most of the other blocks.
                    prev_line = peek_line_delta(-1)
                    if len(line) < 19 + 4 or prev_line[19:19+4] != "MODE":
                        raise ReadFail(f'ERROR reading {self.file_name}: "MODE" expected on line {line_no}')
                    mode = int(self.number(prev_line, 32, 8))
                    prefix = prefix + ["MODE", str(mode)]
                gids_node = self.ensure_path(root, prefix + ["GPFORCE", "GID"])
                read_gpforce_block(gids_node)

            elif "F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 1 )" in line \
            or   "F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )" in line \
            or   "S T R A I N S    I N   S C A L A R   S P R I N G S        ( C E L A S 1 )" in line \
            or   "S T R A I N S    I N   S C A L A R   S P R I N G S        ( C E L A S 2 )" in line \
            or   "S T R E S S E S   I N   S C A L A R   S P R I N G S        ( C E L A S 1 )" in line \
            or   "S T R E S S E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["ELASSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["ELASSTRAINS","EID"])
                elif "F O R C E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["ELASFORCES","EID"])
                else:
                    continue
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    for element_col in range(4):
                        start = element_col * 33
                        if len(line) > start+12 and line[start+12] != " ":
                            eid = int(self.number(line, start + 6,8))
                            self.set(eids_node, str(eid), self.number(line, start + 19, 13))

            elif "F O R C E S   I N   B U S H   E L E M E N T S        ( C B U S H )" in line \
            or   "S T R A I N S   I N   B U S H   E L E M E N T S        ( C B U S H )" in line \
            or   "S T R E S S E S   I N   B U S H   E L E M E N T S        ( C B U S H )" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["BUSHSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["BUSHSTRAINS","EID"])
                elif "F O R C E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["BUSHFORCES","EID"])
                else:
                    continue
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 21,8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    self.set(eid_node, "TX", self.number(line, 34, 13))
                    self.set(eid_node, "TY", self.number(line, 48, 13))
                    self.set(eid_node, "TZ", self.number(line, 62, 13))
                    self.set(eid_node, "RX", self.number(line, 76, 13))
                    self.set(eid_node, "RY", self.number(line, 90, 13))
                    self.set(eid_node, "RZ", self.number(line, 104, 13))

            elif "S T R E S S E S   I N   R O D   E L E M E N T S" in line \
            or   "S T R A I N S   I N   R O D   E L E M E N T S" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["RODSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["RODSTRAINS","EID"])
                else:
                    continue
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 7, 8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    self.set(eid_node, "AXIAL", self.number(line, 18, 13))
                    self.set(eid_node, "AXIALSAFETY", self.number(line, 32, 12, blank_is_inf=True))
                    self.set(eid_node, "TORSIONAL", self.number(line, 44, 13))
                    self.set(eid_node, "TORSIONALSAFETY", self.number(line, 58, 12, blank_is_inf=True))
                    if len(line) > 78 and line[78] != " ":
                        eid = int(self.number(line, 72,8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        self.set(eid_node, "AXIAL", self.number(line, 83, 13))
                        self.set(eid_node, "AXIALSAFETY", self.number(line, 97, 12, blank_is_inf=True))
                        self.set(eid_node, "TORSIONAL", self.number(line, 109, 13))
                        self.set(eid_node, "TORSIONALSAFETY", self.number(line, 123, 12, blank_is_inf=True))

            elif "S T R E S S E S   I N   B A R   E L E M E N T S" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                eids_node = self.ensure_path(root, prefix + ["BARSTRESSES","EID"])
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 2, 8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    self.set(eid_node, "SA1", self.number(line, 13, 13))
                    self.set(eid_node, "SA2", self.number(line, 28, 13))
                    self.set(eid_node, "SA3", self.number(line, 43, 13))
                    self.set(eid_node, "SA4", self.number(line, 58, 13))
                    self.set(eid_node, "AXIAL", self.number(line, 73, 13))
                    line = get_next_line()
                    self.set(eid_node, "SB1", self.number(line, 13, 13))
                    self.set(eid_node, "SB2", self.number(line, 28, 13))
                    self.set(eid_node, "SB3", self.number(line, 43, 13))
                    self.set(eid_node, "SB4", self.number(line, 58, 13))

            elif "S T R E S S E S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )        OPTION = BILIN" in line \
            or   "S T R A I N S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )        OPTION = BILIN" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRAINS","EID"])
                else:
                    eids_node = None # Should never happen but force a failure.
                get_next_line()
                get_next_line()
                line = get_next_line()
                if line[24:24+8] == "DISTANCE":
                    row_1_name = "Z1"
                    row_2_name = "Z2"
                elif line[24:24+9] == "CURVATURE":
                    row_1_name = "MEMB"
                    row_2_name = "CURV"
                else:
                    # Ignore the block if it has an unknown header
                    continue
                if line[121:121+9] == "VON MISES":
                    failure = "VONMISES"
                else:
                    failure = "MAXSHEAR"
                corner = None
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    if line[15:15+3] == "CEN":
                        eid = int(self.number(line, 4,8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        corner = 0
                        corner_gid = None
                    else:
                        corner += 1
                        corner_gid = int(self.number(line, 13, 8))
                    corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                    if corner_gid is not None:
                        self.set(corner_node, "GID", corner_gid)
                    z1_node = self.ensure_path(corner_node, [row_1_name])
                    self.set(z1_node, "XX", self.number(line, 38, 13))
                    self.set(z1_node, "YY", self.number(line, 52, 13))
                    self.set(z1_node, "XY", self.number(line, 66, 13))
                    self.set(z1_node, "PRINCIPALANGLE", self.number(line, 82, 8))
                    self.set(z1_node, "MAJOR", self.number(line, 92, 13))
                    self.set(z1_node, "MINOR", self.number(line, 106, 13))
                    self.set(z1_node, failure, self.number(line, 120, 13))
                    line = get_next_line()
                    z2_node = self.ensure_path(corner_node, [row_2_name])
                    self.set(z2_node, "XX", self.number(line, 38, 13))
                    self.set(z2_node, "YY", self.number(line, 52, 13))
                    self.set(z2_node, "XY", self.number(line, 66, 13))
                    self.set(z2_node, "PRINCIPALANGLE", self.number(line, 82, 8))
                    self.set(z2_node, "MAJOR", self.number(line, 92, 13))
                    self.set(z2_node, "MINOR", self.number(line, 106, 13))
                    self.set(z2_node, failure, self.number(line, 120, 13))

            elif "S T R E S S E S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )" in line \
            or   "S T R E S S E S   I N   T R I A N G U L A R   E L E M E N T S   ( T R I A 3 )" in line \
            or   "S T R A I N S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )" in line \
            or   "S T R A I N S   I N   T R I A N G U L A R   E L E M E N T S   ( T R I A 3 )" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SHELLSTRAINS","EID"])
                else:
                    eids_node = None # Should never happen but force a failure.
                get_next_line()
                line = get_next_line()
                if line[14:14+8] == "DISTANCE":
                    row_1_name = "Z1"
                    row_2_name = "Z2"
                elif line[14:14+9] == "CURVATURE":
                    row_1_name = "MEMB"
                    row_2_name = "CURV"
                else:
                    # Ignore the block if it has an unknown header
                    continue
                if line[120:120+9] == "VON MISES":
                    failure = "VONMISES"
                else:
                    failure = "MAXSHEAR"
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 2,8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    corner_node = self.ensure_path(eid_node, ["CORNER", "0"])
                    z1_node = self.ensure_path(corner_node, [row_1_name])
                    self.set(z1_node, "XX", self.number(line, 31, 13))
                    self.set(z1_node, "YY", self.number(line, 46, 13))
                    self.set(z1_node, "XY", self.number(line, 61, 13))
                    self.set(z1_node, "PRINCIPALANGLE", self.number(line, 77, 8))
                    self.set(z1_node, "MAJOR", self.number(line, 88, 13))
                    self.set(z1_node, "MINOR", self.number(line, 104, 13))
                    self.set(z1_node, failure, self.number(line, 119, 13))
                    line = get_next_line()
                    z2_node = self.ensure_path(corner_node, [row_2_name])
                    self.set(z2_node, "XX", self.number(line, 31, 13))
                    self.set(z2_node, "YY", self.number(line, 46, 13))
                    self.set(z2_node, "XY", self.number(line, 61, 13))
                    self.set(z2_node, "PRINCIPALANGLE", self.number(line, 77, 8))
                    self.set(z2_node, "MAJOR", self.number(line, 88, 13))
                    self.set(z2_node, "MINOR", self.number(line, 104, 13))
                    self.set(z2_node, failure, self.number(line, 119, 13))

            elif "S T R E S S E S   I N   H E X A H E D R O N   S O L I D   E L E M E N T S   ( H E X A )" in line \
            or   "S T R E S S E S   I N    T E T R A H E D R O N   S O L I D   E L E M E N T S   ( C T E T R A )" in line \
            or   "S T R E S S E S   I N   P E N T A H E D R O N   S O L I D   E L E M E N T S   ( P E N T A )" in line \
            or   "S T R A I N S   I N   H E X A H E D R O N   S O L I D   E L E M E N T S   ( H E X A )" in line \
            or   "S T R A I N S   I N    T E T R A H E D R O N   S O L I D   E L E M E N T S   ( C T E T R A )" in line \
            or   "S T R A I N S   I N   P E N T A H E D R O N   S O L I D   E L E M E N T S   ( P E N T A )" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                if "S T R E S S E S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SOLIDSTRESSES","EID"])
                elif "S T R A I N S" in line:
                    eids_node = self.ensure_path(root, prefix + ["SOLIDSTRAINS","EID"])
                else:
                    eids_node = None # Should never happen but force a failure.
                get_next_line()
                get_next_line()
                # Don't reset corner because block can be split across pages between corners.
                # In that case, eid_node and corner will both persist from the previous loop iteration.
                # It can also be split across pages between the element ID line and the first
                # corner lines. In that case, only eid_node needs to persist between loop iterations.
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    if line[3:3+8].strip() != "": # Element ID line
                        eid = int(self.number(line, 4,8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        continue
                    if line[17:17+6] == "CENTER":
                        corner = 0
                        corner_gid = None
                    else:
                        corner += 1
                        corner_gid = int(self.number(line, 16, 8))
                    corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                    if corner_gid is not None:
                        self.set(corner_node, "GID", corner_gid)
                    self.set(corner_node, "XX", self.number(line, 29, 13))
                    self.set(corner_node, "XY", self.number(line, 48, 13))
                    self.set(corner_node, "VONMISES", self.number(line, 117, 13))
                    line = get_next_line()
                    self.set(corner_node, "YY", self.number(line, 29, 13))
                    self.set(corner_node, "YZ", self.number(line, 48, 13))
                    line = get_next_line()
                    self.set(corner_node, "ZZ", self.number(line, 29, 13))
                    self.set(corner_node, "ZX", self.number(line, 48, 13))

            elif "F O R C E S   I N   R O D   E L E M E N T S" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                eids_node = self.ensure_path(root, prefix + ["RODFORCES","EID"])
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 7, 8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    self.set(eid_node, "AXIAL", self.number(line, 22, 13))
                    self.set(eid_node, "TORQUE", self.number(line, 37, 13))
                    if len(line) > 73 and line[73] != " ":
                        eid = int(self.number(line, 67,8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        self.set(eid_node, "AXIAL", self.number(line, 82, 13))
                        self.set(eid_node, "TORQUE", self.number(line, 97, 13))
                               
            elif "F O R C E S   I N   B A R   E L E M E N T S" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                eids_node = self.ensure_path(root, prefix + ["BARFORCES","EID"])
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 6, 8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    self.set(eid_node, "MA1", self.number(line, 18, 13))
                    self.set(eid_node, "MA2", self.number(line, 32, 13))
                    self.set(eid_node, "MB1", self.number(line, 47, 13))
                    self.set(eid_node, "MB2", self.number(line, 61, 13))
                    self.set(eid_node, "S1", self.number(line, 76, 13))
                    self.set(eid_node, "S2", self.number(line, 90, 13))
                    self.set(eid_node, "AXIAL", self.number(line, 105, 13))
                    self.set(eid_node, "TORQUE", self.number(line, 120, 13))

            elif "F O R C E S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )        OPTION = BILIN" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                eids_node = self.ensure_path(root, prefix + ["SHELLFORCES","EID"])
                get_next_line()
                get_next_line()
                get_next_line()
                # Don't reset corner because block can be split across pages between corners.
                # In that case, eid_node and corner will both persist from the previous loop iteration.
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    if line[15:15+3] == "CEN":
                        eid = int(self.number(line, 4,8))
                        eid_node = self.ensure_path(eids_node, [str(eid)])
                        corner = 0
                        corner_gid = None
                    else:
                        corner += 1
                        corner_gid = int(self.number(line, 13, 8))
                    corner_node = self.ensure_path(eid_node, ["CORNER", str(corner)])
                    if corner_gid is not None:
                        self.set(corner_node, "GID", corner_gid)
                    self.set(corner_node, "NXX", self.number(line, 22, 13))
                    self.set(corner_node, "NYY", self.number(line, 36, 13))
                    self.set(corner_node, "NXY", self.number(line, 50, 13))
                    self.set(corner_node, "MXX", self.number(line, 64, 13))
                    self.set(corner_node, "MYY", self.number(line, 78, 13))
                    self.set(corner_node, "MXY", self.number(line, 92, 13))
                    self.set(corner_node, "QX", self.number(line, 106, 13))
                    self.set(corner_node, "QY", self.number(line, 120, 13))

            elif "F O R C E S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )" in line \
            or   "F O R C E S   I N   T R I A N G U L A R   E L E M E N T S   ( T R I A 3 )" in line:
                if is_mode_block():
                    continue
                prefix = subcase_mode()
                eids_node = self.ensure_path(root, prefix + ["SHELLFORCES","EID"])
                get_next_line()
                get_next_line()
                get_next_line()
                while True:
                    line = get_next_line()
                    if line.strip() == "":
                        continue
                    if line[0] == "1":
                        break
                    if line.startswith(" ***"):
                        break
                    eid = int(self.number(line, 4,8))
                    eid_node = self.ensure_path(eids_node, [str(eid)])
                    corner_node = self.ensure_path(eid_node, ["CORNER", "0"])
                    self.set(corner_node, "NXX", self.number(line, 18, 13))
                    self.set(corner_node, "NYY", self.number(line, 32, 13))
                    self.set(corner_node, "NXY", self.number(line, 46, 13))
                    self.set(corner_node, "MXX", self.number(line, 62, 13))
                    self.set(corner_node, "MYY", self.number(line, 76, 13))
                    self.set(corner_node, "MXY", self.number(line, 90, 13))
                    self.set(corner_node, "QX", self.number(line, 106, 13))
                    self.set(corner_node, "QY", self.number(line, 120, 13))

            elif "R E A L   E I G E N V A L U E S" in line:
                # Eigenvalue summary table (not preceded by "EIGENVALUE =" line).
                prefix = subcase_mode()
                get_next_line()  # "MODE    EXTRACTION      EIGENVALUE ..." header
                get_next_line()  # "NO.       ORDER ..." continuation header
                modes_node = self.ensure_path(root, prefix + ["REALEIGENVALUES", "MODE"])
                while True:
                    line = get_next_line()
                    if is_data_line(line):
                        mode = int(self.number(line, 2, 8))
                        mode_node = self.ensure_path(modes_node, [str(mode)])
                        self.set(mode_node, "EIGENVALUE", self.number(line, 28, 12))
                        self.set(mode_node, "CYCLES",     self.number(line, 68, 12))
                    else:
                        break


        return root


    def write_structure_dense(self, file, tree_node, prefix="", parent_key=""):
        # Start at the root
        if tree_node is None:
            tree_node = self.parsed_f06

        is_first = True
        for key, value in tree_node.items():
            # Only show the first GID and EID as an example because there could be a lot.
            if (not is_first) and (parent_key == "GID" \
                                or parent_key == "EID" \
                                or parent_key == "MODE"):
                file.write(prefix + "...\n")
                break
            is_first = False

            if isinstance(value, dict):
                self.write_structure_dense(file, value, prefix + str(key) + "/", key)
            else:
                file.write(prefix + str(key) + "\n")


    def dump(self, file, tree_node=None, prefix="", parent_key=""):
        # Start at the root
        if tree_node is None:
            tree_node = self.parsed_f06

        for key, value in tree_node.items():
            if isinstance(value, dict):
                self.dump(file, value, prefix + str(key) + "/", key)
            else:
                file.write(f"{prefix}{key} = {value}\n")


    def get_layer_0(self, path):
        # Get a value from the file unmolested.
        
        current_node = self.parsed_f06
       
        value = None

        for index, node in enumerate(path):

            if not isinstance(current_node, dict):
                # Fail if we reached the leaf before the end of the path.
                value = None
                break
            if not node in current_node:
                value = None
                break
            else:
                current_node = current_node[node]
                value = current_node

        return value


    def get_layer_1(self, path):
        # Get a value from layer 0 and:
        # - Return 0.0 for missing data in cases where it logically means 0.0.

        value = self.get_layer_0(path)

        if value is None:
            # Some types of missing node represent zero values.
            # But only if the block is present.
            
            # /SC/#/SPCFORCES/GID/#/##
            #                     ^--- gid not present.
            if len(path) == 6 \
            and path[0] == "SC" \
            and path[2] in("DISPLACEMENTS", "SPCFORCES", "MPCFORCES", "APPLIEDFORCES") \
            and path[3] == "GID" \
            and path[5] in("TX","TY","TZ","RX","RY","RZ"):
                if self.get_layer_0(path[0:4]) is not None:
                    value = 0.0

            # /SC/#/GPFORCES/GID/#/#####/##
            #                        ^--- force type not present.
            elif len(path) == 7 \
            and path[0] == "SC" \
            and path[2] == "GPFORCE" \
            and path[3] == "GID" \
            and path[5] in("APPLIED", "SPC", "MPC", "INERTIA") \
            and path[6] in("TX","TY","TZ","RX","RY","RZ"):
                if self.get_layer_0(path[0:5]) is not None:
                    value = 0.0

            # /SC/#/MODE/#/GPFORCES/GID/#/#####/##
            #                               ^--- force type not present.
            elif len(path) == 9 \
            and path[0] == "SC" \
            and path[2] == "MODE" \
            and path[4] == "GPFORCE" \
            and path[5] == "GID" \
            and path[7] in("APPLIED", "SPC", "MPC", "INERTIA") \
            and path[8] in("TX","TY","TZ","RX","RY","RZ"):
                if self.get_layer_0(path[0:5]) is not None:
                    value = 0.0

        return value


    def get_layer_2(self, path, output_file : TextIOWrapper):
        # Get a value from layer 1 and:
        # - Write a message if it doesn't exist.
        
        value = self.get_layer_1(path)

        if value is None:
            output_file.write(f"{INDENT * 1}No value at: {"/".join(path)}\n")
        
            # Show the available paths to help debugging test cases.
            # self.write_structure_dense(output_file, self.parsed_f06)

        return value


    def get_layer_3(self, path, gp_transforms, shell_angles, output_file : TextIOWrapper):
        # Get a value from layer 2 and optionally:
        # - Transform vectors at grid points according to the supplied transformation matrices.
        # - Transform shell stress/strain/force according to the supplied element rotation angles.

        def rotate_2D_rank2_tensor(xx, yy, xy, angle, shear_factor, component):
            if xx is None or yy is None or xy is None:
                return None
            match component:
                case "XX": return (xx + yy) / 2 + (xx - yy) / 2 * math.cos(2*angle) - xy/shear_factor * math.sin(2*angle)
                case "YY": return (xx + yy) / 2 - (xx - yy) / 2 * math.cos(2*angle) + xy/shear_factor * math.sin(2*angle)
                case "XY": return                ((xx - yy) / 2 * math.sin(2*angle) + xy/shear_factor * math.cos(2*angle)) * shear_factor

        
        # Transform displacement components
        if len(path) > 5 \
        and path[0] == "SC" \
        and (path[2] == "DISPLACEMENTS" or path[2] == "SPCFORCES") \
        and path[3] == "GID":
            gid = int(path[4])
            if gid in gp_transforms:
                # Get the 3-component displacement (translation or rotation) vector
                if path[5][0] == "T" or path[5][0] == "R":
                    x_path = path.copy(); x_path[5] = f"{path[5][0]}X"; x = self.get_layer_2(x_path, output_file)
                    y_path = path.copy(); y_path[5] = f"{path[5][0]}Y"; y = self.get_layer_2(y_path, output_file)
                    z_path = path.copy(); z_path[5] = f"{path[5][0]}Z"; z = self.get_layer_2(z_path, output_file)

                    # Transform it but only calculate the requested component
                    if path[5][1] == "X": component = 0
                    if path[5][1] == "Y": component = 1
                    if path[5][1] == "Z": component = 2
                    row = gp_transforms[gid][component]
                    if x is None or y is None or z is None:
                        result = None
                    else:
                        result = row[0] * x + row[1] * y + row[2] * z

        # Transform shell stress, strain, and engineering forces

        if len(path) > 6 \
        and path[0] == "SC" \
        and path[2] == "SHELLSTRESSES" \
        and path[3] == "EID" \
        and path[5] == "CORNER":
            eid = int(path[4])
            if eid in shell_angles:
                corner = int(path[6])
                angle = shell_angles[eid][corner]
                if len(path) > 7 and (path[7] == "YZ" or path[7] == "ZX"):
                    # Transverse shear stress:
                    # SC/#/SHELLSTRESSES/EID/#/CORNER/#/YZ,ZX
                    x_path = path.copy(); x_path[7] = "ZX"; x = self.get_layer_2(x_path, output_file)
                    y_path = path.copy(); y_path[7] = "YZ"; y = self.get_layer_2(y_path, output_file)
                    if x is None or y is None:
                        result = None
                    elif path[7] == "ZX":
                        result = x * math.cos(angle) - y * math.sin(angle)
                    else:
                        result = x * math.sin(angle) + y * math.cos(angle)
                elif len(path) > 8 and (path[8] == "XX" or path[8] == "YY" or path[8] == "XY"):
                    # In-layer stress:
                    # SC/#/SHELLSTRESSES/EID/#/CORNER/#/Z#/XX,YY,XY
                    xx_path = path.copy(); xx_path[8] = "XX"; xx = self.get_layer_2(xx_path, output_file)
                    yy_path = path.copy(); yy_path[8] = "YY"; yy = self.get_layer_2(yy_path, output_file)
                    xy_path = path.copy(); xy_path[8] = "XY"; xy = self.get_layer_2(xy_path, output_file)
                    result = rotate_2D_rank2_tensor(xx, yy, xy, angle, 1, path[8])
                elif len(path) > 8 and path[8] == "PRINCIPALANGLE":
                    result = self.get_layer_2(path, output_file) + angle

        if len(path) > 6 \
        and path[0] == "SC" \
        and path[2] == "SHELLSTRAINS" \
        and path[3] == "EID" \
        and path[5] == "CORNER":
            eid = int(path[4])
            if eid in shell_angles:
                corner = int(path[6])
                angle = shell_angles[eid][corner]
                if len(path) > 7 and (path[7] == "YZ" or path[7] == "ZX"):
                    # Transverse shear strain:
                    # SC/#/SHELLSTRAINS/EID/#/CORNER/#/YZ,ZX
                    x_path = path.copy(); x_path[7] = "ZX"; x = self.get_layer_2(x_path, output_file)
                    y_path = path.copy(); y_path[7] = "YZ"; y = self.get_layer_2(y_path, output_file)
                    if x is None or y is None:
                        result = None
                    elif path[7] == "ZX":
                        result = x * math.cos(angle) - y * math.sin(angle)
                    else:
                        result = x * math.sin(angle) + y * math.cos(angle)
                elif len(path) > 8 and (path[8] == "XX" or path[8] == "YY" or path[8] == "XY"):
                    # In-layer strain:
                    # SC/#/SHELLSTRAINS/EID/#/CORNER/#/Z#/XX,YY,XY
                    xx_path = path.copy(); xx_path[8] = "XX"; xx = self.get_layer_2(xx_path, output_file)
                    yy_path = path.copy(); yy_path[8] = "YY"; yy = self.get_layer_2(yy_path, output_file)
                    xy_path = path.copy(); xy_path[8] = "XY"; xy = self.get_layer_2(xy_path, output_file)
                    result = rotate_2D_rank2_tensor(xx, yy, xy, angle, 2, path[8])
                elif len(path) > 8 and path[8] == "PRINCIPALANGLE":
                    result = self.get_layer_2(path, output_file) + angle

        if len(path) > 6 \
        and path[0] == "SC" \
        and path[2] == "SHELLFORCES" \
        and path[3] == "EID" \
        and path[5] == "CORNER":
            eid = int(path[4])
            if eid in shell_angles:
                corner = int(path[6])
                angle = shell_angles[eid][corner]
                if len(path) > 7 and (path[7] == "QX" or path[7] == "QY"):
                    # Transverse shear force resultant:
                    # SC/#/SHELLFORCES/EID/#/CORNER/#/QX,QY
                    x_path = path.copy(); x_path[7] = "QX"; x = self.get_layer_2(x_path, output_file)
                    y_path = path.copy(); y_path[7] = "QY"; y = self.get_layer_2(y_path, output_file)
                    if x is None or y is None:
                        result = None
                    elif path[7] == "QX":
                        result = x * math.cos(angle) - y * math.sin(angle)
                    else:
                        result = x * math.sin(angle) + y * math.cos(angle)
                elif len(path) > 7 and (path[7] == "NXX" or path[7] == "NYY" or path[7] == "NXY"):
                    # In-layer force resultants:
                    # SC/#/SHELLFORCES/EID/#/CORNER/#/NXX,NYY,NXY
                    xx_path = path.copy(); xx_path[7] = "NXX"; xx = self.get_layer_2(xx_path, output_file)
                    yy_path = path.copy(); yy_path[7] = "NYY"; yy = self.get_layer_2(yy_path, output_file)
                    xy_path = path.copy(); xy_path[7] = "NXY"; xy = self.get_layer_2(xy_path, output_file)
                    result = rotate_2D_rank2_tensor(xx, yy, xy, angle, 1, path[7][-2:])
                elif len(path) > 7 and (path[7] == "MXX" or path[7] == "MYY" or path[7] == "MXY"):
                    # Moment resultants:
                    # SC/#/SHELLFORCES/EID/#/CORNER/#/MXX,MYY,MXY
                    xx_path = path.copy(); xx_path[7] = "MXX"; xx = self.get_layer_2(xx_path, output_file)
                    yy_path = path.copy(); yy_path[7] = "MYY"; yy = self.get_layer_2(yy_path, output_file)
                    xy_path = path.copy(); xy_path[7] = "MXY"; xy = self.get_layer_2(xy_path, output_file)
                    result = rotate_2D_rank2_tensor(xx, yy, xy, angle, 1, path[7][-2:])

        try:
            return result
        except NameError:
            # No change
            return self.get_layer_2(path, output_file)
            

    def get_layer_4(self, path, gp_transforms, shell_angles, gp_coordinates, output_file : TextIOWrapper):
        # Get a value from layer 3 and optionally:
        # - ZMID for shell midsurface
        # - MXORIGIN, MYORIGIN, MZORIGIN for moment about the origin from SPCFORCES and MPCFORCES

        if len(path) > 7 \
        and path[0] == "SC" \
        and (path[2] == "SHELLSTRESSES" or path[2] == "SHELLSTRAINS") \
        and path[3] == "EID" \
        and path[5] == "CORNER" \
        and path[7] == "ZMID":

            z1_path = path.copy(); z1_path[7] = "Z1"; z1 = self.get_layer_3(z1_path, gp_transforms, shell_angles, output_file)
            z2_path = path.copy(); z2_path[7] = "Z2"; z2 = self.get_layer_3(z2_path, gp_transforms, shell_angles, output_file)
            if z1 is None or z2 is None:
                return None
            else:
                return (z1 + z2) / 2

        elif len(path) > 5 \
        and path[0] == "SC" \
        and (path[2] == "SPCFORCES" or path[2] == "MPCFORCES") \
        and path[3] == "GID" \
        and (path[5] == "MXORIGIN" or path[5] == "MYORIGIN" or path[5] == "MZORIGIN"):

            fx_path = path.copy(); fx_path[5] = "TX"
            fx = self.get_layer_3(fx_path, gp_transforms, shell_angles, output_file)
            fy_path = path.copy(); fy_path[5] = "TY"
            fy = self.get_layer_3(fy_path, gp_transforms, shell_angles, output_file)
            fz_path = path.copy(); fz_path[5] = "TZ"
            fz = self.get_layer_3(fz_path, gp_transforms, shell_angles, output_file)
            mx_path = path.copy(); mx_path[5] = "RX"
            mx = self.get_layer_3(mx_path, gp_transforms, shell_angles, output_file)
            my_path = path.copy(); my_path[5] = "RY"
            my = self.get_layer_3(my_path, gp_transforms, shell_angles, output_file)
            mz_path = path.copy(); mz_path[5] = "RZ"
            mz = self.get_layer_3(mz_path, gp_transforms, shell_angles, output_file)

            gid = int(path[4])
           
            match path[5][1]:
                case "X": 
                    if mx is None or fy is None or fz is None:
                        moment = None
                    else:
                        moment = mx + gp_coordinates[gid][1] * fz - gp_coordinates[gid][2] * fy 
                case "Y":
                    if my is None or fz is None or fx is None:
                        moment = None
                    else:
                        moment = my + gp_coordinates[gid][2] * fx - gp_coordinates[gid][0] * fz
                case "Z":
                    if mz is None or fx is None or fy is None:
                        moment = None
                    else:
                        moment = mz + gp_coordinates[gid][0] * fy - gp_coordinates[gid][1] * fx

            return moment

        else:

            return self.get_layer_3(path, gp_transforms, shell_angles, output_file)


    def get_layer_5(self, path, gp_transforms, shell_angles, gp_coordinates, gid_to_corners, output_file : TextIOWrapper):
        # Get a value from layer 4 and optionally:
        # - Node averaging
        
        if (len(path) > 5
                and path[0] == "SC"
                and path[2] in ("SHELLSTRESSES", "SHELLSTRAINS", "SHELLFORCES",
                                "SOLIDSTRESSES", "SOLIDSTRAINS")
                and path[3] == "GID"):
            # Eg: SC/1/SHELLSTRESSES/GID/123/Z1/XX
            gid = path[4]
            rest = path[5:]

            if gid not in gid_to_corners:
                output_file.write(f"{INDENT * 1}GID {gid} not found in reverse lookup. Available GIDs:\n")
                output_file.write(f"{INDENT * 1}")
                for available_gid in gid_to_corners.keys():
                    output_file.write(f"{available_gid}\t")
                output_file.write(f"\n")
                return None

            total   = 0.0
            count   = 0

            output_file.write(f"{INDENT * 1}Node averaging from element values:\n")
            for eid, corner in gid_to_corners[gid]:
                element_path = [path[0], path[1], path[2], "EID", eid, "CORNER", corner] + rest
                value = self.get_layer_4(element_path, gp_transforms, shell_angles, gp_coordinates, output_file)
                output_file.write(f"{INDENT * 2}{"/".join(element_path)} =\t{value}\n")
                if value is not None:
                    total += value
                    count += 1
                else:
                    # gid_to_corners might be inconsistent with the data.
                    output_file.write(f"{INDENT * 1}Strangely no value.\n")
                    return None

            if count == 0:
                output_file.write(f"{INDENT * 1}No elements with data found for GID {gid}.\n")
                return None

            return total / count

        else:

            return self.get_layer_4(path, gp_transforms, shell_angles, gp_coordinates, output_file)


    def get_layer_6(self, path, gp_transforms, shell_angles, gp_coordinates, gid_to_corners, output_file : TextIOWrapper):
        # Get a value from layer 5 and:
        # - Path can describe multiple values.
        
        def expand_lists(path, expanded_paths=None):
            # Convert eg: 
            #
            # ["A","B","1,2,3","D"]
            #   to
            # [["A","B","1","D"], ["A","B","2","D"], ["A","B","3","D"]]
            #
            # and
            #
            # ["2"-"7"]
            #   to
            # ["2","3","4","5","6","7"]
            
            # Initialize inside function because same list persists across calls otherwise.
            if expanded_paths is None:
                expanded_paths = []

            for i, element in enumerate(path):
                if "-" in str(element):
                    first = int(element.split("-")[0])
                    last = int(element.split("-")[1])
                    for value in range(first, last+1):
                        expand_lists(path[:i] + [str(value)] + path[i+1:], expanded_paths)
                    return expanded_paths
                elif "," in str(element):
                    for value in element.split(","):
                        expand_lists(path[:i] + [value.strip()] + path[i+1:], expanded_paths)
                    return expanded_paths
            expanded_paths.append(path)
            return expanded_paths
        
        single_paths = expand_lists(path)

        result = []

        for single_path in single_paths:
            result.append(self.get_layer_5(single_path, gp_transforms, shell_angles, gp_coordinates, gid_to_corners, output_file))

        return result


def main():

    if len(sys.argv) == 2:
        filename = sys.argv[1]
        f06 = F06Query(filename)
        f06.dump(sys.stdout)
    else:
        print()
        print(f"F06_query used as a standalone program dumps the parsed contents of an f06 file to standard output.")
        print(f"Usage: {sys.argv[0]} <filename>")
        print()

if __name__ == "__main__":
    main()