cffview 0.2.0__py3-none-any.whl

cffview/boundary.py

@@ -0,0 +1,306 @@
+from dataclasses import dataclass
+
+
+class BoundaryFactory:
+    _REGISTRY = {}
+
+    @classmethod
+    def register(cls, type_name: str):
+        def decorator(subclass):
+            cls._REGISTRY[type_name] = subclass
+            return subclass
+        return decorator
+
+    @classmethod
+    def create(cls, name: str, id_: str, type_: str):
+        boundary_cls = cls._REGISTRY.get(type_, NotImplementedBoundary)
+        return boundary_cls(name, id_)
+
+
+@dataclass
+@BoundaryFactory.register('fluid')
+class Fluid:
+    name: str
+    id_: str
+    material: str = ''
+    sources: str = ''
+    fixed: str = ''
+    mrf_motion: str = ''
+    mgrid_motion: str = ''
+    solid_motion: str = ''
+    laminar: str = ''
+    porous: str = ''
+    fanzone: str = ''
+
+
+@dataclass
+@BoundaryFactory.register('solid')
+class Solid:
+    name: str
+    id_: str
+    material: str = ''
+    sources: str = ''
+
+
+@dataclass
+@BoundaryFactory.register('velocity-inlet')
+class VelocityInlet:
+    name: str
+    id_: str
+    velocity_spec: str = ''
+    frame_of_reference: str = ''
+    vmag: str = ''
+    t: str = ''
+    ke_spec: str = ''
+    turb_intensity: str = ''
+    turb_hydraulic_diam: str = ''
+    turb_viscosity_ratio: str = ''
+
+    _VELOCITY_SPEC = {
+        '1': 'Magnitude and Direction',
+        '2': 'Magnitude, Normal to Boundary',
+        '3': 'Components',
+    }
+
+    _FRAME_OF_REFERENCE = {
+        '0': 'Absolute',
+        '1': 'Ralative to Adjacent Cell Zone',
+    }
+
+    _KE_SPEC = {
+        '1': 'Intensity and Length Scale',
+        '2': 'Intensity and Viscosity Ratio',
+        '3': 'Intensity and Hydraulic Diameter',
+    }
+
+    def to_dict(self) -> dict[str, str]:
+        data = self.__dict__.copy()
+
+        data['velocity_spec'] = self._VELOCITY_SPEC.get(self.velocity_spec, 'unknown')
+        data['frame_of_reference'] = self._FRAME_OF_REFERENCE.get(self.frame_of_reference, 'unknown')
+        data['ke_spec'] = self._KE_SPEC.get(self.ke_spec, 'unknown')
+
+        match data['ke_spec']:
+            case 'Intensity and Length Scale':
+                data.pop('turb_viscosity_ratio', None)
+                data.pop('turb_hydraulic_diam', None)
+            case 'Intensity and Viscosity Ratio':
+                data.pop('turb_length_scale', None)
+                data.pop('turb_hydraulic_diam', None)
+            case 'Intensity and Hydraulic Diameter':
+                data.pop('turb_length_scale', None)
+                data.pop('turb_viscosity_ratio', None)
+
+        return data
+
+
+@dataclass
+@BoundaryFactory.register('mass-flow-inlet')
+class MassFlowInlet:
+    name: str
+    id_: str
+    mass_flow: str = ''
+    t: str = ''
+    turb_intensity: str = ''
+    turb_hydraulic_diam: str = ''
+    turb_viscosity_ratio: str = ''
+
+
+@dataclass
+@BoundaryFactory.register('mass-flow-outlet')
+class MassFlowOutlet:
+    name: str
+    id_: str
+    mass_flow: str = ''
+    t: str = ''
+    turb_intensity: str = ''
+    turb_hydraulic_diam: str = ''
+    turb_viscosity_ratio: str = ''
+
+
+@dataclass
+@BoundaryFactory.register('pressure-inlet')
+class PressureInlet:
+    name: str
+    id_: str
+    frame_of_reference: str = ''
+    p0: str = ''
+    p: str = ''
+    t0: str = ''
+    ke_spec: str = ''
+    prevent_reverse_flow: str = ''
+    turb_intensity: str = ''
+    turb_length_scale: str = ''
+    turb_hydraulic_diam: str = ''
+    turb_viscosity_ratio: str = ''
+
+    _FRAME_OF_REFERENCE = {
+        '0': 'Absolute',
+        '1': 'Ralative to Adjacent Cell Zone',
+    }
+
+    _KE_SPEC = {
+        '1': 'Intensity and Length Scale',
+        '2': 'Intensity and Viscosity Ratio',
+        '3': 'Intensity and Hydraulic Diameter',
+    }
+
+    def to_dict(self) -> dict[str, str]:
+        data = self.__dict__.copy()
+
+        data['frame_of_reference'] = self._FRAME_OF_REFERENCE.get(self.frame_of_reference, 'unknown')
+        data['ke_spec'] = self._KE_SPEC.get(self.ke_spec, 'unknown')
+
+        match data['ke_spec']:
+            case 'Intensity and Length Scale':
+                data.pop('turb_viscosity_ratio', None)
+                data.pop('turb_hydraulic_diam', None)
+            case 'Intensity and Viscosity Ratio':
+                data.pop('turb_length_scale', None)
+                data.pop('turb_hydraulic_diam', None)
+            case 'Intensity and Hydraulic Diameter':
+                data.pop('turb_length_scale', None)
+                data.pop('turb_viscosity_ratio', None)
+
+        return data
+
+
+@dataclass
+@BoundaryFactory.register('pressure-outlet')
+class PressureOutlet:
+    name: str
+    id_: str
+    p: str = ''
+    t0: str = ''
+    ke_spec: str = ''
+    prevent_reverse_flow: str = ''
+    radial: str = ''
+    avg_press_spec: str = ''
+    turb_intensity: str = ''
+    turb_length_scale: str = ''
+    targeted_mf_boundary: str = ''
+    turb_hydraulic_diam: str = ''
+    turb_viscosity_ratio: str = ''
+
+    _KE_SPEC = {
+        '1': 'Intensity and Length Scale',
+        '2': 'Intensity and Viscosity Ratio',
+        '3': 'Intensity and Hydraulic Diameter',
+    }
+
+    def to_dict(self) -> dict[str, str]:
+        data = self.__dict__.copy()
+
+        if self.prevent_reverse_flow == '#t':
+            for key in ['t', 'ke_spec', 'turb_intensity', 'turb_length_scale', 'targeted_mf_boundary', 'turb_hydraulic_diam', 'turb_viscosity_ratio']:
+                data.pop(key, None)
+        else:
+            data['ke_spec'] = self._KE_SPEC.get(self.ke_spec, 'unknown')
+            match data['ke_spec']:
+                case 'Intensity and Length Scale':
+                    data.pop('turb_viscosity_ratio', None)
+                    data.pop('turb_hydraulic_diam', None)
+                case 'Intensity and Viscosity Ratio':
+                    data.pop('turb_length_scale', None)
+                    data.pop('turb_hydraulic_diam', None)
+                case 'Intensity and Hydraulic Diameter':
+                    data.pop('turb_length_scale', None)
+                    data.pop('turb_viscosity_ratio', None)
+
+        return data
+
+
+@dataclass
+@BoundaryFactory.register('wall')
+class Wall:
+    name: str
+    id_: str
+    d: str = ''
+    q_dot: str = ''
+    material: str = ''
+    thermal_bc: str = ''
+    t: str = ''
+    q: str = ''
+    h: str = ''
+    motion_bc: str = ''
+    shear_bc: str = ''
+    rough_bc: str = ''
+    moving: str = ''
+    relative: str = ''
+    roughness_height: str = ''
+    roughness_const: str = ''
+
+    _THERMAL_BC = {
+        '1': 'Heat Flux',
+        '2': 'Temperature',
+        '3': 'Coupled',
+    }
+
+    _MOTION_BC = {}
+
+    _SHEAR_BC = {}
+
+    _ROUGH_BC = {}
+
+    _THERMAL_BC_WHITELIST = {
+        '1': {'q_dot'},  # Heat Flux
+        '2': {'t'},  # Temperature
+        '3': set(),  # Coupled
+    }
+
+    def to_dict(self) -> dict[str, str]:
+        data = self.__dict__.copy()
+
+        allowed_attrs = self._THERMAL_BC_WHITELIST.get(self.thermal_bc, set())
+        all_thermal_attrs = {'t', 'q_dot', 'h', 'q'}
+        attrs_to_remove = all_thermal_attrs - allowed_attrs
+        for attr in attrs_to_remove:
+            data.pop(attr, None)
+
+        data['thermal_bc'] = self._THERMAL_BC.get(self.thermal_bc, 'unknown')
+
+        return data
+
+
+@dataclass
+@BoundaryFactory.register('porous-jump')
+class PorousJump:
+    name: str
+    id_: str
+    alpha: str = ''
+    dm: str = ''
+    c2: str = ''
+
+
+@dataclass
+@BoundaryFactory.register('fan')
+class Fan:
+    name: str
+    id_: str
+
+
+@dataclass
+@BoundaryFactory.register('radiator')
+class Radiator:
+    name: str
+    id_: str
+
+
+@dataclass
+@BoundaryFactory.register('interior')
+class Interior:
+    name: str
+    id_: str
+
+
+@dataclass
+@BoundaryFactory.register('symmetry')
+class Symmetry:
+    name: str
+    id_: str
+
+
+@dataclass
+class NotImplementedBoundary:
+    name: str
+    id_: str

cffview/main.py

@@ -0,0 +1,524 @@
+def print_version(file_path: str) -> str:
+    """Get the version of the .h5 file
+
+    Parameters
+    ---------
+    file_path : str
+        Path to the .h5 file
+
+    Returns
+    -------
+    str
+        Version of the .h5 file
+    """
+    import h5py
+
+    with h5py.File(file_path, "r") as f:
+        print(f['/settings/Version'][0].decode())
+
+
+def read_case(file_path: str, **kwargs) -> dict[str]:
+    """Read the cas.h5 file
+
+    Parameters
+    ---------
+    file_path : str
+        Path to the cas.h5 file
+
+    Returns
+    -------
+    dict[str]
+        A dictionary containing the case settings
+    """
+    import re
+    import h5py
+
+    with h5py.File(file_path) as f:
+        settings: h5py.Group = f['/settings']
+        general_info = settings['Rampant Variables'][0].decode()
+        boundary_info = settings['Thread Variables'][0].decode()
+
+    if not any(kwargs.values()):
+        kwargs = dict.fromkeys(kwargs.keys(), True)
+
+    data = {}
+
+    if kwargs['solver']:
+        case_config = re.search(
+            r'^\(case-config.*',
+            general_info,
+            re.M
+        ).group()
+        kvs = {
+            m[0]: m[1]
+            for m in re.findall(
+                r"\(([^()\s]+)\s+\.\s+([^()\s]+)\)",
+                case_config
+            )
+        }
+
+        data['solver'] = {}
+        data['solver']['type'] = "pbns" if kvs['rp-seg?'] == "#t" else "dbns"
+        data['solver']['time'] = "transient" if kvs['rp-unsteady?'] == "#t" else "steady"
+        data['solver']['dimension'] = "3d" if kvs['rp-3d?'] == "#t" else "2d"
+        data['solver']['precision'] = "double" if kvs['rp-double?'] == "#t" else "single"
+        data['solver']['axi'] = "true" if kvs['rp-axi?'] == "#t" else "false"
+        data['solver']['init'] = "hybrid" if kvs['hyb-init?'] == "#t" else "standard"
+
+        if kvs['rp-visc?'] == "#f":
+            data['solver']['turb'] = "inviscid"
+        else:
+            for key in [
+                'rp-lam?', 'rp-ke?', 'rp-kw?', 'rp-sa?', 'sg-rsm?',
+                'rp-les?', 'rp-des?', 'rp-kklw', 'rp-v2f?'
+            ]:
+                if kvs[key] == "#t":
+                    data['solver']['turb'] = key[3:-1]
+                    break
+
+        data['solver']['energy'] = "true" if kvs['rf-energy?'] == "#t" else "false"
+        data['solver']['radiation'] = "false"
+        for key in ['sg-rosseland?', 'sg-p1?', 'sg-dtrm?', 'sg-s2s?', 'sg-disco?']:
+            if kvs[key] != "#f":
+                data['solver']['radiation'] = key[3:-1]
+                break
+
+        gravity = re.search(
+            r'\(gravity\?\s+([^)\s]+)\)',
+            general_info
+        ).group(1)
+        if gravity == "#t":
+            axes = ['x', 'y', 'z'] if data['solver']['dimension'] == "3d" else ['x', 'y']
+            for axis in axes:
+                sel = re.search(
+                    fr'\(gravity/{axis}-sel\s+"([^"]+)"\)',
+                    general_info
+                ).group(1)
+                expr = re.search(
+                    fr'\(gravity/{axis}-expr\s+"([^"]+)"\)',
+                    general_info
+                ).group(1)
+                data['solver'][f'gravity/{axis}'] = f'{sel}/{expr}'
+        else:
+            data['solver']['gravity'] = "false"
+
+        operating_conditions = [
+            'operating-pressure',
+            'pressure-reference/x', 'pressure-reference/y', 'pressure-reference/z',
+            'operating-temperature',
+        ]
+        use_operating_density = re.search(
+            r'\(use-operating-density\?\s+([^)\s]+)\)',
+            general_info
+        ).group(1)
+        if use_operating_density == '#t':
+            operating_conditions.append('operating-density')
+        for condition in operating_conditions:
+            sel = re.search(
+                fr'\({condition}-sel\s+"([^"]+)"\)',
+                general_info
+            ).group(1)
+            expr = re.search(
+                fr'\({condition}-expr\s+"([^"]+)"\)',
+                general_info
+            ).group(1)
+            data['solver'][condition] = f'{sel}/{expr}'
+
+    if kwargs['mat']:
+        import sexpdata
+
+        data['materials'] = {}
+        materials = re.search(
+            r'(\(materials.*)',
+            general_info,
+            re.M
+        ).group(1)
+        materials: list = sexpdata.loads(materials)
+        for material in materials[1]:
+            name = str(material[0])
+            data['materials'][name] = {}
+            data['materials'][name]['type'] = str(material[1])
+            for i in range(2, len(material)):
+                property_ = material[i]
+                if property_[1] == sexpdata.Symbol('.'):
+                    data['materials'][name][str(property_[0])] = str(property_[2])
+                elif isinstance(p1 := property_[1], list):
+                    if p1[1] == sexpdata.Symbol('.'):
+                        data['materials'][name][str(property_[0])] = f'{p1[0]}/{p1[2]}'
+                    else:
+                        value = ' '.join(str(p) for p in p1[1:])
+                        data['materials'][name][str(property_[0])] = f'{p1[0]}/{value}'
+
+    if kwargs['bd']:
+        import sexpdata
+        from .boundary import BoundaryFactory
+
+        data['boundary'] = {}
+        boundaries: list[list] = sexpdata.parse(boundary_info, true=None)
+        for boundary_info in boundaries:
+            id_, type_, name, _ = [str(_) for _ in boundary_info[1]]
+            new_boundary = BoundaryFactory.create(name, id_, type_)
+            b_list = data['boundary'].get(type_, [])
+
+            for property_ in boundary_info[2]:
+                property_name = str(property_[0]).replace('-', '_').replace('?', '').replace('/', '_')
+                if hasattr(new_boundary, property_name):
+                    if property_[1] == sexpdata.Symbol('.'):
+                        setattr(new_boundary, property_name, str(property_[2]))
+                    elif isinstance(property_[1], list):
+                        setattr(new_boundary, property_name, f'{property_[1][0]}/{property_[1][2]}')
+
+            b_list.append(new_boundary.to_dict() if hasattr(new_boundary, 'to_dict') else new_boundary.__dict__)
+            data['boundary'][type_] = b_list
+
+    if kwargs['ne']:
+        import sexpdata
+
+        data['named-expressions'] = {}
+        nes = re.search(
+            r'(\(named-expressions.*)',
+            general_info,
+            re.M
+        ).group(1)
+        nes: list = sexpdata.loads(nes, true=None)[1]
+        for ne in nes:
+            ne_dict = {
+                str(property_[0]): str(property_[2])
+                for property_ in ne
+            }
+            data['named-expressions'][ne_dict['name']] = ne_dict
+
+    if kwargs['disc']:
+        from .utils import FLUENT_ENUM
+
+        data['disc-scheme'] = {}
+        disc_scheme = {
+            ds[0]: FLUENT_ENUM[ds[1]]
+            for ds in re.findall(
+                r'\((.*)/scheme\s+(\d+)\)',
+                general_info
+            )
+        }
+        for eq in ['flow', 'pressure', 'mom', 'temperature', 'k', 'omega', 'epsilon']:
+            data['disc-scheme'][eq] = disc_scheme.get(eq)
+
+        data['relax-factor'] = {}
+        if data['disc-scheme']['flow'] == 'Coupled':
+            for eq in ['pressure', 'mom']:
+                data['relax-factor'][eq] = re.search(
+                    fr'\(pressure-coupled/{eq}/pseudo-explicit-relax\s+([\d.]+)\)',
+                    general_info
+                ).group(1)
+            for eq in ['temperature', 'k', 'omega', 'epsilon', 'turb-viscosity', 'density', 'body-force']:
+                data['relax-factor'][eq] = re.search(
+                    fr'\({eq}/pseudo-relax\s+([\d.]+)\)',
+                    general_info
+                ).group(1)
+        else:
+            relax_factor = {
+                ur[0]: ur[1]
+                for ur in re.findall(
+                    fr'\((.*)/relax\s+([\d.]+)\)',
+                    general_info
+                )
+            }
+            for eq in ['pressure', 'mom', 'temperature', 'k', 'omega', 'epsilon', 'turb-viscosity', 'density', 'body-force']:
+                data['relax-factor'][eq] = relax_factor.get(eq, '')
+
+    if kwargs['rd']:
+        import sexpdata
+
+        data['report-definitions'] = {}
+        rds = re.search(
+            r'(\(monitor/report-definitions.*)',
+            general_info,
+            re.M
+        ).group(1)
+        rds: list = sexpdata.loads(rds, true=None)[1]
+        for rd in rds:
+            name = str(rd[0][2])
+            type_ = str(rd[1][1])
+            data['report-definitions'][name] = {'type': type_}
+            if 'volume' in type_:
+                data['report-definitions'][name]['field'] = str(rd[1][2][2])
+                data['report-definitions'][name]['zones'] = [str(zone) for zone in rd[1][6][1:]]
+                data['report-definitions'][name]['per-zone?'] = str(rd[1][-5][2])
+            elif 'surface' in type_:
+                data['report-definitions'][name]['field'] = str(rd[1][2][2])
+                data['report-definitions'][name]['surfaces'] = [str(surface) for surface in rd[1][5][1:]]
+                data['report-definitions'][name]['per-surface?'] = str(rd[1][-5][2])
+            elif 'flux' in type_:
+                data['report-definitions'][name]['zones'] = [str(zone) for zone in rd[1][3][1:]]
+                data['report-definitions'][name]['per-zone?'] = str(rd[1][-5][2])
+
+    if kwargs['plotsets']:
+        import sexpdata
+
+        data['plotsets'] = {}
+        plotsets = re.search(
+            r'(\(monitor/plotsets.*)',
+            general_info,
+            re.M
+        ).group(1)
+        plotsets: list = sexpdata.loads(plotsets, true=None)[1]
+        for plotset in plotsets:
+            plotset_dict = {
+                str(property_[0]): str(property_[2])
+                for property_ in plotset
+                if str(property_[0]) not in ['old-props', 'report-defs']
+            }
+            plotset_dict['report-defs'] = plotset[6][1:]
+            data['plotsets'][plotset_dict['name']] = plotset_dict
+
+    if kwargs['monitorsets']:
+        import sexpdata
+
+        data['monitorsets'] = {}
+        monitorsets = re.search(
+            r'(\(monitor/monitorsets.*)',
+            general_info,
+            re.M
+        ).group(1)
+        monitorsets: list = sexpdata.loads(monitorsets, true=None)[1]
+        for monitorset in monitorsets:
+            monitorset_dict = {
+                str(property_[0]): str(property_[2])
+                for property_ in monitorset
+                if str(property_[0]) not in ['old-props', 'report-defs']
+            }
+            monitorset_dict['report-defs'] = monitorset[-4][1:]
+            data['monitorsets'][monitorset_dict['name']] = monitorset_dict
+
+    if kwargs['iter']:
+        data['iter'] = {}
+
+        if not (solver_time := data.get('solver', {}).get('time', None)):
+            case_config = re.search(
+                r'^\(case-config.*',
+                general_info,
+                re.M
+            ).group()
+            is_unsteady = re.search(
+                r"\(rp-unsteady\?\s+\.\s+([^()\s]+)\)",
+                case_config
+            ).group(1)
+            solver_time = "transient" if is_unsteady == "#t" else "steady"
+
+        if solver_time == 'steady':
+            data['iter']['iterations'] = re.search(
+                r'\(number-of-iterations\s+(\d+)\)',
+                general_info
+            ).group(1)
+        else:
+            sel = re.search(
+                r'\(physical-time-step-sel\s+"([^"]+)"\)',
+                general_info
+            ).group(1)
+            expr = re.search(
+                r'\(physical-time-step-expr\s+"([^"]+)"\)',
+                general_info
+            ).group(1)
+            data['iter']['physical-time-step'] = f'{sel}/{expr}'
+            for key in ['time-steps', 'max-iters-per-step', 'time-step', 'flow-time']:
+                data['iter'][key] = re.search(
+                    fr'\({key}\s+(\d+)\)',
+                    general_info
+                ).group(1)
+
+    return data
+
+
+def extract_h5(file_path: str) -> None:
+    """Extract cas.h5 general and boundary string to files
+
+    Parameters
+    ---------
+    file_path : str
+        Path to the cas.h5 file
+    """
+    import h5py
+    with h5py.File(file_path) as f:
+        settings: h5py.Group = f['/settings']
+        general_info = settings['Rampant Variables'][0].decode()
+        boundary_info = settings['Thread Variables'][0].decode()
+    with open('general.scm', 'w', encoding='utf-8') as f:
+        f.write(general_info)
+    with open('boundary.scm', 'w', encoding='utf-8') as f:
+        f.write(boundary_info)
+
+
+def show_mesh(file_path: str) -> None:
+    """Show mesh with PyVista
+
+    Parameters
+    ---------
+    file_path : str
+        Path to the .h5 file
+    """
+    import pyvista as pv
+    if file_path.endswith('cas.h5'):
+        pv.plot(
+            pv.read(file_path, progress_bar=True),
+            show_edges=True,
+            show_axes=True,
+            smooth_shading=True,
+            split_sharp_edges=True,
+        )
+    elif file_path.endswith('msh.h5'):
+        import numpy as np
+        from h5py import File, Group, Dataset
+
+        with File(file_path) as f:
+            root_group: Group = f['/meshes/1']
+            dimension: np.int32 = root_group.attrs['dimension'][0]
+            nodeCount: np.uint64 = root_group.attrs['nodeCount'][0]
+            faceCount: np.uint64 = root_group.attrs['faceCount'][0]
+            pv_points = np.zeros((nodeCount, 3), dtype=np.float64)
+            nnodes = np.zeros(faceCount, dtype=np.int16)
+            zoneTopology: Group = root_group['nodes/zoneTopology']
+            nZones: np.uint64 = zoneTopology.attrs['nZones'][0]
+            minId: Dataset = zoneTopology['minId']
+            maxId: Dataset = zoneTopology['maxId']
+
+            coords_group: Group = root_group['nodes/coords']
+            for i in range(nZones):
+                pv_points[minId[i] - 1: maxId[i], :dimension] = coords_group[f'{i+1}'][:]
+
+            zoneTopology: Group = root_group['faces/zoneTopology']
+            minId: Dataset = zoneTopology['minId']
+            maxId: Dataset = zoneTopology['maxId']
+
+            faces_nodes_group: Group = root_group['faces/nodes']
+            nSections: np.uint64 = faces_nodes_group.attrs['nSections'][0]
+            for i in range(nSections):
+                section_group: Group = faces_nodes_group[f"{i+1}"]
+                nnodes[minId[i] - 1: maxId[i]] = section_group['nnodes'][:]
+            nodes_count = np.sum(nnodes)
+            nodes = np.zeros(nodes_count, dtype=np.uint32)
+            nodes_start_index = 0
+            for i in range(nSections):
+                section_group: Group = faces_nodes_group[f"{i+1}"]
+                nodes_num = section_group['nodes'].size
+                nodes[nodes_start_index: nodes_start_index + nodes_num] = section_group['nodes'][:] - 1
+                nodes_start_index += nodes_num
+            offsets = np.cumsum(nnodes) - nnodes
+            pv_faces = np.insert(nodes, offsets, nnodes)
+
+        mesh = pv.PolyData(pv_points, pv_faces)
+        plotter = pv.Plotter()
+        plotter.add_mesh(mesh, show_edges=True, color='cyan', line_width=2, smooth_shading=True, split_sharp_edges=True)
+        plotter.add_axes()
+        plotter.show()
+
+
+def main() -> None:
+    import argparse
+
+    desc = "A Python CLI tool to inspect Ansys Fluent .cas.h5/.msh.h5 files without opening Fluent"
+    parser = argparse.ArgumentParser(description=desc)
+
+    parser.add_argument(
+        "file_path",
+        type=str,
+        help="path to the .h5 file"
+    )
+
+    parser.add_argument(
+        "--extract",
+        action="store_true",
+        help="extract cas.h5 general and boundary string to files"
+    )
+
+    parser.add_argument(
+        "-v", "--version",
+        action="store_true",
+        help="show the version of the .h5 file"
+    )
+
+    parser.add_argument(
+        "--solver",
+        action="store_true",
+        help="show solver settings"
+    )
+    parser.add_argument(
+        "--mat", "--materials",
+        action="store_true",
+        help="show materials settings"
+    )
+    parser.add_argument(
+        "--bd", "--boundary",
+        action="store_true",
+        help="show boundary settings"
+    )
+    parser.add_argument(
+        "--ne", "--named-expressions",
+        action="store_true",
+        help="show named-expressions settings"
+    )
+    parser.add_argument(
+        "--disc",
+        action="store_true",
+        help="show disc-scheme and relax-factor settings"
+    )
+    parser.add_argument(
+        "--rd", "--report-definitions",
+        action="store_true",
+        help="show report-definitions settings"
+    )
+    parser.add_argument(
+        "--plotsets",
+        action="store_true",
+        help="show report-definitions plotsets settings"
+    )
+    parser.add_argument(
+        "--monitorsets",
+        action="store_true",
+        help="show report-definitions monitorsets settings"
+    )
+    parser.add_argument(
+        "--iter",
+        action="store_true",
+        help="show iteration settings"
+    )
+    parser.add_argument(
+        "--save",
+        action="store_true",
+        help="save output to file"
+    )
+    parser.add_argument(
+        "--showmesh",
+        action="store_true",
+        help="show mesh using pyvista"
+    )
+
+    args = parser.parse_args()
+
+    if args.version:
+        print_version(args.file_path)
+    elif args.extract:
+        extract_h5(args.file_path)
+    elif args.file_path.endswith(".msh.h5"):
+        show_mesh(args.file_path)
+    elif args.file_path.endswith(".cas.h5"):
+        if args.showmesh:
+            show_mesh(args.file_path)
+        else:
+            from .utils import print_colored_dict
+            kwargs = {
+                'solver': args.solver,
+                'mat': args.mat,
+                'bd': args.bd,
+                'ne': args.ne,
+                'disc': args.disc,
+                'rd': args.rd,
+                'plotsets': args.plotsets,
+                'monitorsets': args.monitorsets,
+                'iter': args.iter
+            }
+            output = read_case(args.file_path, **kwargs)
+            print_colored_dict(output)
+
+            if args.save:
+                import json
+                with open(f"{args.file_path}.json", "w", encoding="utf-8") as f:
+                    json.dump(output, f, ensure_ascii=False, indent=4)

cffview/utils.py

@@ -0,0 +1,125 @@
+# From context.scm
+FLUENT_ENUM = {
+    "0": "First Order Upwind",
+    "1": "Second Order Upwind",
+    "2": "Power Law",
+    "3": "Central Difference",
+    "4": "Quick",
+    "5": "Modified HRIC",
+    "6": "Third-Order MUSCL",
+    "7": "Bounded Central Differencing",
+    "8": "CICSAM",
+    "9": "Low Diffusion Second Order",
+    "10": "Standard",
+    "11": "Linear",
+    "12": "Second Order",
+    "13": "Body Force Weighted",
+    "14": "PRESTO!",
+    "15": "Continuity Based",
+    "16": "Geo-Reconstruct",
+    "17": "Donor-Acceptor",
+    "18": "Modified Body Force Weighted",
+    "20": "SIMPLE",
+    "21": "SIMPLEC",
+    "22": "PISO",
+    "23": "Phase Coupled SIMPLE",
+    "24": "Coupled",
+    "25": "Fractional Step",
+    "28": "Compressive",
+    "29": "BGM",
+    "30": "Phase Coupled PISO",
+    "31": "Low Diffusion Central",
+}
+
+FLUENT_BOUNDARY_TYPES = {
+    2: "interior",
+    3: "wall",
+    4: "inlet-vent",
+    4: "pressure-inlet",
+    4: "intake-fan",
+    5: "pressure-outlet",
+    5: "outlet-vent",
+    5: "exhaust-fan",
+    7: "symmetry",
+    9: "pressure-far-field",
+    10: "velocity-inlet",
+    14: "radiator",
+    14: "fan",
+    14: "porous-jump",
+    20: "mass-flow-inlet",
+    20: "mass-flow-outlet",
+    24: "interface",
+    25: "overset",
+    36: "outflow",
+    37: "axis",
+}
+
+CELL_TYPES = {
+    1: "Triangle",
+    2: "Tetrahedron",
+    3: "Quadrilateral",
+    4: "Hexahedral",
+    5: "Pyramid",
+    6: "Wedge",
+    7: "Polyhedron",
+}
+
+
+def print_colored_dict(data) -> None:
+    """Print nested data in 4-space JSON format.
+
+    Keys (including colon) : cycle through 6 hued colours per nesting level.
+    String values          : bright white  — no hue, never clashes with any key colour.
+    Numbers / bool / null  : white-grey    — no hue, never clashes with any key colour.
+    """
+    # 6 hued colours used exclusively for keys
+    LEVEL_COLORS = [
+        "\033[36m",  # cyan
+        "\033[32m",  # green
+        "\033[33m",  # yellow
+        "\033[35m",  # magenta
+        "\033[34m",  # blue
+        "\033[31m",  # red
+    ]
+    STR_COLOR = "\033[97m"  # bright white — string values
+    PRIM_COLOR = "\033[37m"  # white-grey   — numbers / booleans / null
+    RESET = "\033[0m"
+
+    import re
+    import json
+
+    # Three capture groups: key (with quotes) | colon + whitespace | value (with optional trailing comma)
+    KV_RE = re.compile(r'^("(?:[^"\\]|\\.)*")(:\s*)(.+)$')
+
+    text = json.dumps(data, indent=4, ensure_ascii=False, default=str)
+
+    for line in text.splitlines():
+        content = line.lstrip(" ")
+        level = (len(line) - len(content)) // 4
+        indent = " " * (len(line) - len(content))
+        lc = LEVEL_COLORS[level % len(LEVEL_COLORS)]
+
+        m = KV_RE.match(content)
+        if m:
+            key, colon, rest = m.group(1), m.group(2), m.group(3)
+            # Strip trailing comma only for type detection; print the original `rest`
+            bare = rest.rstrip(",").strip()
+
+            if bare in ("{", "["):
+                # Value is an opening bracket — keep structural chars in the level colour
+                print(f"{indent}{lc}{key}{colon}{rest}{RESET}")
+            elif bare.startswith('"'):
+                print(f"{indent}{lc}{key}{colon}{RESET}{STR_COLOR}{rest}{RESET}")
+            else:
+                # Number / boolean / null
+                print(f"{indent}{lc}{key}{colon}{RESET}{PRIM_COLOR}{rest}{RESET}")
+        else:
+            # Structural line ({ } [ ]) or bare array element
+            bare = content.rstrip(",").strip()
+            if bare.startswith('"'):
+                print(f"{indent}{STR_COLOR}{content}{RESET}")
+            elif bare in ("{", "}", "[", "]"):
+                print(f"{indent}{lc}{content}{RESET}")
+            else:
+                # Number / boolean / null inside an array
+                print(f"{indent}{PRIM_COLOR}{content}{RESET}")

cffview-0.2.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: cffview
+Version: 0.2.0
+Summary: A Python CLI tool to inspect Ansys Fluent .cas.h5/.msh.h5 files without opening Fluent
+Author-email: preamer <1524477126@qq.com>
+License-Expression: BSD-3-Clause
+Project-URL: Repository, https://github.com/preamer/cffview
+Keywords: fluent,cfd,ansys,hdf5,mesh
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Environment :: Console
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: h5py>=3.16.0
+Requires-Dist: pyvista>=0.48.4
+Requires-Dist: sexpdata>=1.0.2
+Requires-Dist: tqdm>=4.68.3
+Dynamic: license-file
+
+[中文](README.zh.md)
+
+# cffview
+
+A command-line tool for inspecting Ansys Fluent `.cas.h5` / `.msh.h5` files **without opening Fluent**.
+
+- Read solver settings, materials, boundary conditions, discretisation schemes, and more directly from the HDF5 file.
+- Visualise the mesh with [PyVista](https://pyvista.org).
+
+---
+
+## Installation
+
+```bash
+pip install cffview
+```
+
+### Build from source
+
+```bash
+git clone https://github.com/preamer/cffview.git
+cd cffview
+pip install .
+```
+
+---
+
+## Usage
+
+```
+cffview <file> [options]
+```
+
+### Options
+
+| Option | Description |
+|---|---|
+| `-v`, `--version` | Print the Fluent version stored in the file |
+| `--extract` | Dump raw Scheme settings to `general.scm` and `boundary.scm` |
+| `--showmesh` | Visualise the mesh interactively with PyVista |
+| `--solver` | Solver type, time, dimension, precision, turbulence model, energy, radiation, gravity |
+| `--mat` | Material properties |
+| `--bd` | Boundary condition settings |
+| `--ne` | Named expressions |
+| `--disc` | Discretisation schemes and relaxation factors |
+| `--rd` | Report definitions |
+| `--plotsets` | Plot sets |
+| `--monitorsets` | Monitor sets |
+| `--iter` | Iteration / time-step settings |
+| `--save` | Save the output to `<file>.json` |
+
+Multiple flags can be combined freely. Case settings flags (`--solver`, `--mat`, etc.) apply to `.cas.h5` files only.
+
+### Examples
+
+```bash
+# Show solver configuration and boundary conditions
+cffview case.cas.h5 --solver --bd
+
+# Show all settings and save to JSON
+cffview case.cas.h5 --solver --mat --bd --ne --disc --rd --iter --save
+
+# Visualise the mesh (.cas.h5 and .msh.h5 both supported)
+cffview case.cas.h5 --showmesh
+cffview mesh.msh.h5 --showmesh
+
+# Check the Fluent version embedded in the file
+cffview case.cas.h5 --version
+
+# Extract raw Scheme strings for manual inspection
+cffview case.cas.h5 --extract
+```
+
+---
+
+## File Format Support
+
+| Feature | `.cas.h5` | `.msh.h5` |
+|---|---|---|
+| Case settings (`--solver`, `--mat`, `--bd`, …) | ✅ | — |
+| Mesh visualisation (3D) | ✅ | ✅ |
+| Mesh visualisation (2D) | ✅ | ✅ |
+
+---
+
+## Supported Settings
+
+| Flag | Contents |
+|---|---|
+| `--solver` | Algorithm (PBNS/DBNS), steady/transient, 2D/3D, single/double precision, turbulence model, energy, radiation, gravity |
+| `--mat` | Fluid/solid materials with properties and evaluation methods |
+| `--bd` | Velocity-inlet, pressure-outlet, mass-flow-inlet/outlet, wall (thermal & motion BC), porous-jump, interior, symmetry, … |
+| `--ne` | Named expressions defined in the case |
+| `--disc` | Per-equation scheme (Second Order Upwind, QUICK, …) and under-relaxation / pseudo-transient factors |
+| `--rd` | Report definitions (volume, surface, flux) with field, zones, and per-zone flag |
+| `--plotsets` | Plot set configurations |
+| `--monitorsets` | Monitor set configurations |
+| `--iter` | Iteration count (steady) or time-step size, number of steps, max inner iterations (transient) |
+
+---
+
+## License
+
+[BSD-3-Clause](LICENSE)

cffview-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+cffview/boundary.py,sha256=Qf_VCbKlr3Wb2Jad0bgHfzFo7Ha3kE8RftIZgOfwvfY,7652
+cffview/main.py,sha256=-ejDB4En0RSkDHQAEIK-ChlozGhTkzDmTrtufeOGidw,18348
+cffview/utils.py,sha256=bJTjNvKMVVWMz-75AjWzEwf7l-EbPVru1bLay6gpIWY,3863
+cffview-0.2.0.dist-info/licenses/LICENSE,sha256=fX5KINFPzeX8XkVSp0LkkDa8x7lNrL6HRM3KNAyEGZU,1493
+cffview-0.2.0.dist-info/METADATA,sha256=dWSzgNpLV893moxqRyEfLxSg532MjNcgIUG2jt0Pgcs,3884
+cffview-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+cffview-0.2.0.dist-info/entry_points.txt,sha256=QPeK1LuSRH44i315vFZnvNz_DyXiipMbE0Q6wbXjiSw,46
+cffview-0.2.0.dist-info/top_level.txt,sha256=VnE4_JsocgSYopbiqxE9oI4435vuwaE_ATafiEeztc8,8
+cffview-0.2.0.dist-info/RECORD,,

cffview-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cffview-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cffview = cffview.main:main

cffview-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, preamer
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cffview-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cffview