plot3d 1.8.2__tar.gz → 1.9.0__tar.gz

{plot3d-1.8.2 → plot3d-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3d
-Version: 1.8.2
+Version: 1.9.0
 Summary: Plot3D python utilities for reading and writing and also finding connectivity between blocks
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/__init__.py

@@ -3,9 +3,9 @@ from importlib import import_module
 import os, warnings
 
 from .block import Block
-from .blockfunctions import rotate_block, get_outer_bounds, block_connection_matrix,split_blocks, plot_blocks, reduce_blocks, find_matching_faces, compute_min_gcd, scale_face_bounds, constant_axis
+from .blockfunctions import rotate_block, get_outer_bounds, block_connection_matrix,split_blocks, plot_blocks, reduce_blocks, find_matching_faces, compute_min_gcd, scale_face_bounds, constant_axis, make_right_handed
 from .block_merging_mixed_facepairs import combine_nxnxn_cubes_mixed_pairs
-from .connectivity import find_matching_blocks, get_face_intersection, connectivity_fast, face_matches_to_dict, PERMUTATION_MATRICES
+from .connectivity import find_matching_blocks, get_face_intersection, connectivity_fast, face_matches_to_dict, PERMUTATION_MATRICES, normalize_face_matches
 from .face import Face
 from .facefunctions import create_face_from_diagonals, get_outer_faces, find_bounding_faces,split_face,find_face_nearest_point,match_faces_dict_to_list,outer_face_dict_to_list,find_closest_block
 from .read import read_plot3D, read_ap_nasa
@@ -13,7 +13,8 @@ from .write import write_plot3D
 from .differencing import find_edges, find_face_edges
 from .periodicity import periodicity, periodicity_fast, create_rotation_matrix, rotated_periodicity, translational_periodicity
 from .verify import (verify_connectivity, verify_periodicity,
-                      extract_canonical_grid, apply_permutation, verify_match,
+                      extract_canonical_grid, extract_directed_grid,
+                      apply_permutation, verify_match,
                       verify_partial_match, try_all_permutations, get_bounds,
                       determine_plane)
 from .point_match import point_match

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/block.py

@@ -188,9 +188,58 @@ class Block:
             'kmax': (self.X[:,:,-1], self.Y[:,:,-1], self.Z[:,:,-1]),
         }
         
+    def check_handedness(self) -> bool:
+        """Check if the block has right-handed (positive volume) cells.
+
+        Samples cells at the block center and corners using a scalar
+        triple product.  Returns ``True`` if right-handed, ``False``
+        if left-handed (negative volume).
+        """
+        X, Y, Z = self.X, self.Y, self.Z
+        ni, nj, nk = self.IMAX, self.JMAX, self.KMAX
+        if ni < 2 or nj < 2 or nk < 2:
+            return True  # degenerate block, nothing to check
+
+        # Sample a few representative cells
+        samples = [
+            (ni // 2, nj // 2, nk // 2),   # center
+            (0, 0, 0),                       # corner
+            (ni - 2, nj - 2, nk - 2),       # opposite corner
+        ]
+        total = 0.0
+        for i, j, k in samples:
+            if i >= ni - 1 or j >= nj - 1 or k >= nk - 1:
+                continue
+            p000 = np.array([X[i, j, k], Y[i, j, k], Z[i, j, k]])
+            d1 = np.array([X[i+1,j,k] - p000[0], Y[i+1,j,k] - p000[1], Z[i+1,j,k] - p000[2]])
+            d2 = np.array([X[i,j+1,k] - p000[0], Y[i,j+1,k] - p000[1], Z[i,j+1,k] - p000[2]])
+            d3 = np.array([X[i,j,k+1] - p000[0], Y[i,j,k+1] - p000[1], Z[i,j,k+1] - p000[2]])
+            total += np.dot(d1, np.cross(d2, d3))
+        return total >= 0
+
+    def fix_handedness(self) -> bool:
+        """Fix left-handed blocks by reversing the k-axis.
+
+        If the block has negative cell volumes (left-handed), the
+        k-index is reversed so that the cell orientation becomes
+        right-handed.  Reversing k (spanwise) preserves the i and j
+        conventions (i=chord, j=wall-normal) that connectivity and
+        boundary conditions depend on.
+
+        Returns:
+            bool: ``True`` if a fix was applied, ``False`` if already
+            right-handed.
+        """
+        if self.check_handedness():
+            return False
+        self.X = self.X[:, :, ::-1].copy()
+        self.Y = self.Y[:, :, ::-1].copy()
+        self.Z = self.Z[:, :, ::-1].copy()
+        return True
+
     @property
     def size(self)->int:
-        """returns the total number of nodes 
+        """returns the total number of nodes
 
         Returns:
             int: number of nodes

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/blockfunctions.py

@@ -481,3 +481,100 @@ def build_connectivity_graph(connectivities: List[List[Dict]]) -> nx.Graph:
         block2 = pair['block2']['block_index'] # type: ignore
         G.add_edge(block1, block2)
     return G
+
+
+def make_right_handed(
+    blocks: List[Block],
+    face_matches: Optional[List[dict]] = None,
+    periodic_matches: Optional[List[dict]] = None,
+    outer_faces: Optional[List[dict]] = None,
+    block_names: Optional[List[str]] = None,
+    flip_axis: int = 2,
+) -> Tuple[List[Block], List[dict], List[dict], List[dict]]:
+    """Make all blocks right-handed by reversing one axis on left-handed blocks.
+
+    A left-handed block has majority-negative cell volumes (computed via
+    the Davies & Salmond hexahedral formula).  This commonly occurs when
+    converting from cylindrical to Cartesian coordinates.  GlennHT and
+    other structured solvers require right-handed blocks.
+
+    For each left-handed block the function:
+    1. Reverses the chosen axis in the X, Y, Z arrays.
+    2. Remaps all connectivity indices for that block:
+       ``idx -> n - 1 - idx`` along the flipped axis.
+
+    Parameters
+    ----------
+    blocks : list of Block
+        Plot3D blocks (modified in place and returned).
+    face_matches : list of dict, optional
+        Interface connectivity records (modified in place).
+    periodic_matches : list of dict, optional
+        Periodic connectivity records (modified in place).
+    outer_faces : list of dict, optional
+        Boundary-condition face records (modified in place).
+    block_names : list of str, optional
+        Names for log output.  If None, blocks are numbered.
+    flip_axis : int
+        Which axis to reverse on left-handed blocks: 0=i, 1=j, 2=k.
+        Default 2 (k) preserves the i/j blade-plane topology.
+
+    Returns
+    -------
+    (blocks, face_matches, periodic_matches, outer_faces)
+        The same objects, modified in place, for convenience.
+    """
+    if face_matches is None:
+        face_matches = []
+    if periodic_matches is None:
+        periodic_matches = []
+    if outer_faces is None:
+        outer_faces = []
+
+    flipped: List[int] = []
+
+    for bi, b in enumerate(blocks):
+        vol = b.cell_volumes()
+        interior = vol[1:, 1:, 1:]
+        n_neg = int(np.sum(interior < 0))
+        if n_neg <= interior.size // 2:
+            continue  # already right-handed (or mixed — leave alone)
+
+        # Flip the chosen axis
+        slices = [slice(None)] * 3
+        slices[flip_axis] = slice(None, None, -1)
+        s = tuple(slices)
+        b.X = np.ascontiguousarray(b.X[s])
+        b.Y = np.ascontiguousarray(b.Y[s])
+        b.Z = np.ascontiguousarray(b.Z[s])
+
+        name = block_names[bi] if block_names else str(bi)
+        dim_name = "ijk"[flip_axis]
+        n_dim = [b.IMAX, b.JMAX, b.KMAX][flip_axis]
+        print(f"  make_right_handed: flipped {name} {dim_name}-axis ({n_dim} planes)")
+        flipped.append(bi)
+
+    if not flipped:
+        return blocks, face_matches, periodic_matches, outer_faces
+
+    # Remap connectivity indices for flipped blocks
+    def _remap_face(face: dict) -> None:
+        bi = face["block_index"]
+        if bi not in flipped:
+            return
+        b = blocks[bi]
+        n = [b.IMAX, b.JMAX, b.KMAX][flip_axis]
+        for key in ("lb", "ub"):
+            face[key] = list(face[key])  # ensure mutable
+            face[key][flip_axis] = n - 1 - face[key][flip_axis]
+
+    for m in face_matches:
+        _remap_face(m["block1"])
+        _remap_face(m["block2"])
+    for m in periodic_matches:
+        _remap_face(m["block1"])
+        _remap_face(m["block2"])
+    for of in outer_faces:
+        _remap_face(of)
+
+    return blocks, face_matches, periodic_matches, outer_faces

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/connectivity.py

@@ -733,6 +733,19 @@ def get_face_intersection(face1:Face,face2:Face,block1:Block,block2:Block,tol:fl
                 df = __filter_block_increasing(df,'i2')
                 df = __filter_block_increasing(df,'j2')
 
+            # Reject matches where matched points don't cover the full
+            # matched sub-face area.  Two blocks that share only edges
+            # (e.g. O-grid SS and PS sharing LE/TE lines) can pass the
+            # edge check above because the matched points span two
+            # separate edges, making the diagonal look like a face.
+            # Verify that matched point count == expected sub-face area.
+            if len(df) >= 4:
+                ilb1, jlb1, klb1 = int(df['i1'].min()), int(df['j1'].min()), int(df['k1'].min())
+                iub1, jub1, kub1 = int(df['i1'].max()), int(df['j1'].max()), int(df['k1'].max())
+                matched_area = _face_point_count([ilb1, jlb1, klb1], [iub1, jub1, kub1])
+                if matched_area > 0 and len(df) < matched_area:
+                    df = pd.DataFrame()  # Not a face — only partial (edge) coverage
+
             # Do a final check after doing all these checks
             if len(df)>=4:       # Greater than 4 because match can occur with simply 4 corners but the interior doesn't match.
                 # Check for Split faces
@@ -896,7 +909,7 @@ def combinations_of_nearest_blocks(blocks:List[Block],nearest_nblocks:int=4):
                 new_combos.append((i,j))
     return new_combos
     
-def connectivity_fast(blocks:List[Block]):
+def connectivity_fast(blocks:List[Block], use_minmax:bool=False):
     """Find connectivity by GCD-reducing blocks first for speed.
 
     Computes the minimum GCD across all block dimensions, reduces all blocks
@@ -907,6 +920,10 @@ def connectivity_fast(blocks:List[Block]):
 
     Args:
         blocks (List[Block]): List of blocks to find connectivity for.
+        use_minmax (bool): If True, normalise lb/ub to strict min/max
+            order (IMIN,JMIN,KMIN → IMAX,JMAX,KMAX) and recompute the
+            permutation matrix accordingly.  Default is False (traversal
+            order).
 
     Returns:
         (List[Dict]): Face matches with orientation info.
@@ -921,6 +938,8 @@ def connectivity_fast(blocks:List[Block]):
     # scale it up
     scale_face_bounds(face_matches, gcd_to_use)
     scale_face_bounds(outer_faces_formatted, gcd_to_use)
+    if use_minmax:
+        face_matches = normalize_face_matches(face_matches)
     return face_matches, outer_faces_formatted
 
 def connectivity(blocks:List[Block]):
@@ -1253,3 +1272,93 @@ def face_matches_to_dict(face1:Face, face2:Face,block1:Block,block2:Block):
     return match
 
 
+def normalize_face_matches(face_matches: list) -> list:
+    """Convert face match lb/ub to strict min/max order.
+
+    By default the library encodes traversal direction in lb/ub ordering
+    (lb is not necessarily < ub).  This function normalises every face
+    match so that ``lb = [IMIN, JMIN, KMIN]`` and ``ub = [IMAX, JMAX,
+    KMAX]`` on **both** sides, and recomputes the orientation /
+    permutation matrix accordingly.
+
+    The resulting PM satisfies::
+
+        Face_A(IMIN,JMIN,KMIN -> IMAX,JMAX,KMAX) * PM
+            = Face_B(IMIN,JMIN,KMIN -> IMAX,JMAX,KMAX)
+
+    Parameters
+    ----------
+    face_matches : list of dict
+        Face match dicts as returned by :func:`connectivity_fast` or
+        :func:`connectivity`.  Each dict must have ``block1`` and
+        ``block2`` sub-dicts with ``lb`` and ``ub`` keys.  If a ``match``
+        key (point-match DataFrame) is present it is used to recompute
+        the orientation; otherwise the orientation is recomputed from the
+        new min/max bounds.
+
+    Returns
+    -------
+    list of dict
+        A **new** list with the same structure, but lb/ub in min/max
+        order and orientation updated.
+    """
+    out = []
+    for fm in face_matches:
+        fm = deepcopy(fm)
+        lb1 = fm['block1']['lb']
+        ub1 = fm['block1']['ub']
+        lb2 = fm['block2']['lb']
+        ub2 = fm['block2']['ub']
+
+        new_lb1 = [min(lb1[d], ub1[d]) for d in range(3)]
+        new_ub1 = [max(lb1[d], ub1[d]) for d in range(3)]
+        new_lb2 = [min(lb2[d], ub2[d]) for d in range(3)]
+        new_ub2 = [max(lb2[d], ub2[d]) for d in range(3)]
+
+        fm['block1']['lb'] = new_lb1
+        fm['block1']['ub'] = new_ub1
+        fm['block2']['lb'] = new_lb2
+        fm['block2']['ub'] = new_ub2
+
+        # Recompute orientation if we have the point-match DataFrame
+        # with the expected columns (i1,j1,k1,i2,j2,k2)
+        df = fm.get('match')
+        has_point_match = (df is not None and isinstance(df, pd.DataFrame)
+                          and len(df) > 1 and 'i2' in df.columns)
+        if has_point_match:
+            orientation = _compute_orientation(df, new_lb1, new_ub1)
+            perm_idx, plane = _orient_vec_to_permutation(
+                orientation, new_lb1, new_ub1, new_lb2, new_ub2)
+            export_perm = -1 if plane == 'in-plane' else perm_idx
+            fm['orientation'] = {
+                'permutation_index': export_perm,
+                'plane': plane,
+                'permutation_matrix': PERMUTATION_MATRICES[perm_idx].tolist(),
+            }
+        elif 'orientation' in fm:
+            # No DataFrame — recompute from min/max bounds.
+            # With min/max ordering, all axes go forward, so reversal
+            # flags depend only on the axis mapping (no direction flip).
+            ca1 = _constant_axis(new_lb1, new_ub1)
+            ca2 = _constant_axis(new_lb2, new_ub2)
+            plane = 'in-plane' if ca1 == ca2 else 'cross-plane'
+
+            # Build identity-like orientation: face1 axis d -> face2 axis d
+            # unless cross-plane, in which case use the old orientation's
+            # permutation matrix to infer the mapping.
+            old_perm = fm['orientation'].get('permutation_matrix')
+            if old_perm is not None and plane == 'cross-plane':
+                # Preserve the cross-plane axis swap from original
+                fm['orientation']['plane'] = plane
+            else:
+                # In-plane with min/max ordering: both sides go forward,
+                # so the PM is identity (no reversal, no swap).
+                perm_idx = 0
+                fm['orientation'] = {
+                    'permutation_index': -1,
+                    'plane': plane,
+                    'permutation_matrix': PERMUTATION_MATRICES[perm_idx].tolist(),
+                }
+
+        out.append(fm)
+    return out

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/glennht/__init__.py

@@ -5,5 +5,19 @@ from .class_definitions import BoundaryConditionType,InletBC_Subtype,InletBC_Dir
 # Job related stuff
 from .class_definitions import JobFiles, JobControl, TurbModelInput, Plot3DParameters, InitialCond, TimeStpControl, SPDSchemeControl, RKSchemeControl, MGSchemeControl, GasPropertiesInput, ReferenceCondFull, Job
 
-# export functions 
-from .export_functions import export_to_boundary_condition, export_to_job_file
+# export functions
+from .export_functions import export_to_boundary_condition, export_to_job_file
+
+# validation functions
+from .validation import (
+    check_handedness,
+    check_corners,
+    check_verify_connectivity,
+    check_verify_periodicity,
+    compute_pm,
+    check_pm,
+    check_face_coverage,
+    check_negative_volumes,
+    check_face_normals,
+    run_all_checks,
+)

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/glennht/class_definitions.py

@@ -4,6 +4,15 @@ from dataclasses import dataclass, field
 from enum import IntEnum, Enum
 from typing import Any, Dict, List, Optional
 
+
+class FortranLiteral(str):
+    """String subclass for Fortran namelist values that must NOT be quoted.
+
+    Use for repeat-count arrays (``4*T``, ``0.25,0.3333333,0.5,1.,6*0``)
+    and any other raw Fortran syntax that the namelist reader expects unquoted.
+    """
+    pass
+
 # ----------------------------
 # Enums (mirror your C#)
 # ----------------------------
@@ -89,6 +98,8 @@ class InletBC(BoundaryCondition):
     bet1_const: Optional[float] = None
 
     annular_inlet: bool = False
+    mult_for_full_ring: Optional[int] = None
+    angularPeriod: Optional[float] = None
     deltah: Optional[float] = None
     deltat: Optional[float] = None
     twall_hub: Optional[float] = None
@@ -241,41 +252,36 @@ class TimeStpControl:
 @dataclass
 class SPDSchemeControl:
     # GlennHT-style defaults (with shorthand preserved)
-    NS_Central: str = "4*T"
-    TB2_Upwind1: str = "4*T"
-    NS_Upwind2: str = "4*F"
+    NS_Central: FortranLiteral = FortranLiteral("4*T")
+    TB2_Upwind1: FortranLiteral = FortranLiteral("4*T")
+    NS_Upwind2: FortranLiteral = FortranLiteral("4*F")
 
     ScalrCoeff_ArtDiss: bool = True
     useSecDiffArtDiss: bool = True
     useFrthDiffArtDiss: bool = True
 
-    rk2: str = "4*0.12500"
-    rk4: str = "4*0.032"
+    rk2: FortranLiteral = FortranLiteral("4*0.12500")
+    rk4: FortranLiteral = FortranLiteral("4*0.032")
 
-    # Keep other optional fields from your previous version
     NS_Upwind1: bool = False
     use_AUSM_Chima: bool = False
     use_AUSM_Liou_hTot: bool = False
     TB2_Central: bool = False
     TBRSM_Central: bool = False
     TBRSM_Upwind1: bool = True
-    constArtDiss: bool = False
-    scalarArtDiss: bool = True
+    ConstCoeff_ArtDiss: bool = False
     MatrxCoeff_ArtDiss: bool = False
-    secDiffArtDiss: bool = True
-    matrixArtDiss: bool = False
-    frthDiffArtDiss: bool = True
     MachCutOff: float = 0.1
     ivanAlbada: int = 1
 
 @dataclass
 class RKSchemeControl:
     nStages: int = 4
-    RKCoeff: str = "0.25,0.3333333,0.5,1.,6*0"
-    compute_pdiff_in_stage: str = "T,T,T,T,6*F"
-    compute_adiss_in_stage: str = "T,T,T,T,6*F"
-    export_import_after_stage: str = "T,T,T,T,6*F"
-    use_implicit_residual_smoothing: str = ".T."
+    RKCoeff: FortranLiteral = FortranLiteral("0.25,0.3333333,0.5,1.,6*0")
+    compute_pdiff_in_stage: FortranLiteral = FortranLiteral("T,T,T,T,6*F")
+    compute_adiss_in_stage: FortranLiteral = FortranLiteral("T,T,T,T,6*F")
+    export_import_after_stage: FortranLiteral = FortranLiteral("T,T,T,T,6*F")
+    use_implicit_residual_smoothing: FortranLiteral = FortranLiteral(".T.")
     irs_neqs: Optional[int] = 1
     irs_use_GS: bool = True
     n_GS_iterations: Optional[int] = 3
@@ -309,26 +315,31 @@ class GasPropertiesInput:
 
 @dataclass
 class ReferenceCond:
-    # Derived (not user input) — kept for export
+    # Minimal set for GlennHT: only fields that are explicitly set get exported.
+    # When Re is NOT specified, GlennHT requires:
+    #   Group 0: refLen, refVisc
+    #   Group 1: 3 of {refP0, refT0, refRho0, Rgas}
+    #   Group 2: gamma or refCp
+    #   Group 3: Pr or refCond
     useDimensionalVariables: bool = False
-    refLen: Optional[float] = 1.0
-    refP0: Optional[float] = 101325.0  # Pa (total)
-    refT0: Optional[float] = 300.0
-    refRho0: Optional[float] = 1.1765823
-    refVel: Optional[float] = 293.4588
-    refVisc: Optional[float] = 1.84e-5
-    refCond: Optional[float] = 0.02636
-    refCp: Optional[float] = 1004.5784
-    MolW: Optional[float] = 28.964
-    RgasUnv: Optional[float] = 8314.4126
-    Rgas: Optional[float] = 287.06023
-    gamma: Optional[float] = 1.4
-    Re: Optional[float] = 1.8765e7
-    Pr: Optional[float] = 0.706
-    ndVisc: Optional[float] = 1.0
-    ndCond: Optional[float] = 1.0
-    Omegab: Optional[float] = 0.0
-    ReScalingFactor: Optional[float] = 1.0
+    refLen: Optional[float] = None
+    refP0: Optional[float] = None
+    refT0: Optional[float] = None
+    refRho0: Optional[float] = None
+    refVel: Optional[float] = None
+    refVisc: Optional[float] = None
+    refCond: Optional[float] = None
+    refCp: Optional[float] = None
+    MolW: Optional[float] = None
+    RgasUnv: Optional[float] = None
+    Rgas: Optional[float] = None
+    gamma: Optional[float] = None
+    Re: Optional[float] = None
+    Pr: Optional[float] = None
+    ndVisc: Optional[float] = None
+    ndCond: Optional[float] = None
+    Omegab: Optional[float] = None
+    ReScalingFactor: Optional[float] = None
     rho_solid: Optional[float] = None
     cond_solid: Optional[float] = None
     Csp_solid: Optional[float] = None

{plot3d-1.8.2 → plot3d-1.9.0}/plot3d/glennht/export_functions.py

@@ -116,12 +116,17 @@ def _fmt_bool(v: bool) -> str:
 
 def _fmt_value(v: Any) -> str:
     from enum import Enum, IntEnum
+    from .class_definitions import FortranLiteral
     if isinstance(v, bool):
         return _fmt_bool(v)
     if isinstance(v, (IntEnum, Enum)):
         return str(int(v))
-    if isinstance(v, (int, float)):
+    if isinstance(v, int):
         return repr(v)
+    if isinstance(v, float):
+        return f"{v:.4g}"
+    if isinstance(v, FortranLiteral):
+        return str(v)
     if isinstance(v, str):
         return f"'{v}'"
     if isinstance(v, (list, tuple)):
@@ -195,7 +200,7 @@ def _write_gif_pair(w, pair: Any) -> None:
     )
     w.write(f" &GIF_Spec\nSurfID_1={sid1}, SurfID2={sid2}\n &END\n\n")
 
-def _write_vzconditions(w, vz: Any) -> None:
+def _write_vzconditions(w, vz: Any, ref_T0: float = 285.0) -> None:
     """
     Convert inputs like:
       {"block_index": 1, "zone_type": "fluid"|"solid", "contiguous_index": 1}
@@ -207,10 +212,11 @@ def _write_vzconditions(w, vz: Any) -> None:
 
     if vztype == 1:
         # Fluid default
+        t_ref = _get_field(vz, "Fluid_Tref", ref_T0)
         w.write(
             " &VZConditions\n"
-            f"VZid={vzid}, VZtype=1, OmegaVZ=0., VZMaterialName=Air,\n"
-            "Fluid_Tref_prop=0., Fluid_k_Tref=285., Fluid_amu_Tref=285., Fluid_expnt=.7,UseDryAir=.TRUE.,\n"
+            f"VZid={vzid}, VZtype=1, OmegaVZ=0., VZMaterialName='Air',\n"
+            f"Fluid_Tref_prop=0., Fluid_k_Tref={t_ref}, Fluid_amu_Tref={t_ref}, Fluid_expnt=.7,\n"
             "!Fluid_cp=1002., Fluid_Pr=.7, Fluid_MW=28.964\n"
             " &END\n\n"
         )
@@ -218,7 +224,7 @@ def _write_vzconditions(w, vz: Any) -> None:
         # Solid default
         w.write(
             " &VZConditions\n"
-            f"VZid={vzid}, VZtype=2, OmegaVZ=0., VZMaterialName=CMC,\n"
+            f"VZid={vzid}, VZtype=2, OmegaVZ=0., VZMaterialName='CMC',\n"
             "Solid_Tref_prop=285., Solid_rho_Tref=2707. , Solid_condN_Tref=6.5, Solid_condT_Tref=6.5, Solid_condA_Tref=6.5,\n"
             "Solid_Csp_Tref=896.\n"
             " &END\n\n"
@@ -299,28 +305,31 @@ def populate_reference_from_inputs(
     rcfull.cond_solid = 20.0
     rcfull.csp_solid  = 896.0
 
-    # compact RefCond derived from Full (stored back on the job)
+    # Fill GasPropertiesInput constants from computed values so the job
+    # file doesn't contain -1e+99 sentinel defaults.
+    gas = job.GasPropertiesInput
+    gas.const_cp = cp
+    gas.const_visc = mu
+    gas.const_kth = k_val
+    gas.SpecialGasMW = MolW
+    if gas.RefT_Properties is None or gas.RefT_Properties < -1e+90:
+        gas.RefT_Properties = T0
+
+    # compact RefCond — minimal set so GlennHT derives the rest:
+    #   Group 0: refLen, refVisc
+    #   Group 1: refP0, refT0, Rgas  (3 of 4)
+    #   Group 2: gamma
+    #   Group 3: Pr
     rc = ReferenceCond(
         useDimensionalVariables=False,
         refLen=rcfull.reflen,
         refP0=rcfull.refP0,
         refT0=rcfull.refT0,
-        refRho0=rcfull.refrho0,
-        refVel=rcfull.refVel,
-        refVisc=rcfull.refvisc,
-        refCond=rcfull.refcond,
-        refCp=rcfull.refCp,
-        MolW=rcfull.MolW,
-        RgasUnv=rcfull.RgasUnv,
         Rgas=rcfull.Rgas,
         gamma=rcfull.gamma,
-        Re=rcfull.Re,
+        refVisc=rcfull.refvisc,
         Pr=rcfull.Pr,
-        ndVisc=1.0,
-        ndCond=1.0,
         Omegab=rcfull.Omegab,
-        ReScalingFactor=1.0,
-        rho_solid=rcfull.rho_solid,
         cond_solid=rcfull.cond_solid,
         Csp_solid=rcfull.csp_solid,
     )
@@ -413,8 +422,7 @@ def export_to_boundary_condition(
                 _set_field(inlet, "twall_hub", _get_field(inlet, "twall_hub") / ref.refT0)
             if _get_field(inlet, "twall_case") is not None and ref.refT0 not in (None, 0):
                 _set_field(inlet, "twall_case", _get_field(inlet, "twall_case") / ref.refT0)
-            if _get_field(inlet, "Ts_const") is not None and ref.reflen not in (None, 0):
-                _set_field(inlet, "Ts_const", _get_field(inlet, "Ts_const") / ref.reflen)
+            # Ts_const is nondimensional (turbulence length scale) — no normalization needed
             _write_bsurf_spec(w, inlet)
 
         # OUTLETS (normalize back-pressure by refP0)
@@ -440,9 +448,10 @@ def export_to_boundary_condition(
         for vz in volume_zones:
             key = _first_field(vz, ("contiguous_index", "contiguous_id"))
             volume_zone_unique[key] = vz
+        ref_T0 = getattr(getattr(job_settings, "ReferenceCondFull", None), "refT0", 285.0) or 285.0
         for vz in volume_zone_unique.values():
             if _get_field(vz, "zone_type") is not None:
-                _write_vzconditions(w, vz)
+                _write_vzconditions(w, vz, ref_T0=ref_T0)
             else:
                 w.write(_export_namelist_block("VZConditions", vz)); w.write("\n")
         
@@ -451,8 +460,13 @@ def export_to_boundary_condition(
             if sid is not None:
                 _set_field(obj, field_name, sid)
 
-        # Detailed BC blocks (skip meta + *_unit)
-        exclude = {"Name", "SurfaceID", "BCType"}
+        # Detailed BC blocks (skip meta + *_unit + base-class fields).
+        # IsPostProcessing, IsCalculateMassFlow, ToggleProcessSurface belong
+        # in &BSurf_Spec only — GlennHT's INLET_BC/OUTLET_BC/WALL_BC namelists
+        # do not include them and will reject unrecognised names.
+        exclude = {"Name", "SurfaceID", "BCType",
+                   "IsPostProcessing", "IsCalculateMassFlow",
+                   "ToggleProcessSurface"}
         for inlet in bc_group.Inlets:
             _sync_detail_surface_id(inlet, "surfID_inlet")
             w.write(f"! {inlet.Name}\n")
@@ -613,13 +627,15 @@ def export_to_glennht_conn(matches:List[Dict[str, Dict[int, str]]],outer_faces:L
     for k,v in summary['zone_types_by_id'].items():
         lines.append(f"{k} ")
     lines.append("\n")
-    # Print Zone Groups
+    # Print Zone Groups (all block contiguous indices on one line,
+    # wrapping after columns_to_print entries)
     columns_to_print = 10
-    for i,v in enumerate(volume_zones):
-        if i % columns_to_print==0:
-            lines.append(f"{v["contiguous_index"]}\n")
+    for i, v in enumerate(volume_zones):
+        lines.append(f"{v['contiguous_index']}")
+        if (i + 1) % columns_to_print == 0 or i == len(volume_zones) - 1:
+            lines.append("\n")
         else:
-            lines.append(f"{v["contiguous_index"]} ")
+            lines.append(" ")
     
     filename = ensure_extension(filename,'.ght_conn')
     with open(f'{filename}','w') as fp: