med2limit 0.0.1__py3-none-any.whl

med2limit/__init__.py

@@ -0,0 +1,7 @@
+"""med2limit — MED/RMED to LIMIT converter for Code_Aster shell and solid models."""
+
+from .converter import MEDToLimitConverter
+from .cli import main
+
+__version__ = "0.1.0"
+__all__ = ["MEDToLimitConverter", "main"]

med2limit/cli.py

@@ -0,0 +1,106 @@
+"""
+Command-line entry point.
+
+Two modes:
+- in-script configuration: edit the constants below for Salome / IDE direct runs
+- CLI: standard argparse mode
+
+This module does NOT call sys.exit() so it stays Salome-safe.
+"""
+
+import argparse
+import os
+
+from .converter import MEDToLimitConverter
+
+
+VERSION = "0.1.0"
+
+
+# ---------------------------------------------------------------------------
+# In-script configuration (edit for Salome / direct IDE execution)
+# ---------------------------------------------------------------------------
+
+INPUT_MED = ""
+OUTPUT_LINP = ""
+OUTPUT_LUI = ""
+ORIENTATION_MED = None
+ACTIVE_GROUPS = []
+ACTIVE_NSETS = []
+
+USE_IN_SCRIPT_CONFIGURATION = False
+
+
+def _parse_name_list(text_value: str):
+    if not text_value:
+        return []
+    return [item.strip() for item in text_value.split(",") if item.strip()]
+
+
+def _from_in_script_config():
+    return (
+        INPUT_MED,
+        OUTPUT_LINP or os.path.splitext(INPUT_MED)[0] + ".linp",
+        OUTPUT_LUI or os.path.splitext(INPUT_MED)[0] + ".lui",
+        ORIENTATION_MED,
+        list(ACTIVE_GROUPS),
+        list(ACTIVE_NSETS),
+    )
+
+
+def _from_cli():
+    parser = argparse.ArgumentParser(
+        description=f"MED/RMED to LIMIT converter ({VERSION})"
+    )
+    parser.add_argument("input_med")
+    parser.add_argument("output_linp", nargs="?")
+    parser.add_argument("output_lui", nargs="?")
+    parser.add_argument("orientation_med", nargs="?", default=None)
+    parser.add_argument("--groups", default="")
+    parser.add_argument("--nsets", default="")
+    args, _unknown = parser.parse_known_args()
+
+    return (
+        args.input_med,
+        args.output_linp or os.path.splitext(args.input_med)[0] + ".linp",
+        args.output_lui or os.path.splitext(args.input_med)[0] + ".lui",
+        args.orientation_med,
+        _parse_name_list(args.groups),
+        _parse_name_list(args.nsets),
+    )
+
+
+def main():
+    if USE_IN_SCRIPT_CONFIGURATION and INPUT_MED:
+        (input_file, out_linp, out_lui, orient, groups, nsets) = _from_in_script_config()
+        print("Running in in-script configuration mode")
+    else:
+        (input_file, out_linp, out_lui, orient, groups, nsets) = _from_cli()
+
+    print(f"  input          : {input_file}")
+    print(f"  output_linp    : {out_linp}")
+    print(f"  output_lui     : {out_lui}")
+    print(f"  orientation_med: {orient}")
+    print(f"  groups         : {groups}")
+    print(f"  nsets          : {nsets}")
+
+    if not os.path.exists(input_file):
+        print(f"ERROR: Input file not found: {input_file}")
+        return 1
+    if orient and not os.path.exists(orient):
+        print(f"ERROR: Orientation file not found: {orient}")
+        return 1
+
+    converter = MEDToLimitConverter(
+        med_filename=input_file,
+        linp_filename=out_linp,
+        lui_filename=out_lui,
+        orientation_med_filename=orient,
+        active_groups=groups,
+        active_nsets=nsets,
+    )
+    return 0 if converter.convert() else 1
+
+
+if __name__ == "__main__":
+    main()

med2limit/converter.py

@@ -0,0 +1,127 @@
+"""
+Top-level orchestrator. Public step methods allow debugging in a notebook.
+
+Typical use:
+    converter = MEDToLimitConverter("model.rmed", "out.linp", "out.lui",
+                                    active_groups=["Shell1", "Shell2"])
+    converter.convert()
+
+Step-by-step debug:
+    converter.step_1_load()
+    converter.step_2_extract_mesh()
+    print(converter.mesh.all_nodes)   # inspect
+    converter.step_3_extract_fields()
+    ...
+"""
+
+from .reader import MedFileReader
+from .mesh import MeshExtractor
+from .fields import FieldExtractor
+from .orientation import ShellMetadata
+from .filter import ActiveFilter
+from .writer import LinpWriter, LuiWriter
+
+
+class MEDToLimitConverter:
+    """Orchestrate the MED → LIMIT conversion pipeline."""
+
+    def __init__(self, med_filename, linp_filename, lui_filename,
+                 orientation_med_filename=None,
+                 active_groups=None, active_nsets=None):
+        self.med_filename = med_filename
+        self.linp_filename = linp_filename
+        self.lui_filename = lui_filename
+        self.orientation_med_filename = orientation_med_filename
+        self.active_groups = list(active_groups or [])
+        self.active_nsets = list(active_nsets or [])
+
+        # Filled at runtime
+        self.reader = None
+        self.mesh = None
+        self.fields = None
+        self.shell_meta = None
+        self.filter = None
+
+    # --------------------------------------------------------------- steps
+
+    def step_1_load(self):
+        """Open the main MED/RMED file."""
+        print(f"Loading MED file: {self.med_filename}")
+        self.reader = MedFileReader(self.med_filename)
+        print(f"  Found {len(self.reader.meshes)} mesh(es)")
+        print(f"  Found {len(self.reader.fields)} field(s)")
+        for f in self.reader.fields:
+            print(f"    - {f.getName()}")
+
+    def step_2_extract_mesh(self):
+        """Extract nodes, elements, element groups and node groups."""
+        print("\nExtracting mesh...")
+        self.mesh = MeshExtractor(
+            self.reader.meshes, self.active_groups, self.active_nsets
+        )
+        self.mesh.extract_all()
+        print(f"  Total nodes: {len(self.mesh.all_nodes)}")
+        print(f"  Total elements: {len(self.mesh.all_elements)}")
+        print(f"  Element sets: {list(self.mesh.element_sets.keys())}")
+        print(f"  Node sets: {list(self.mesh.node_sets.keys())}")
+
+    def step_3_extract_fields(self):
+        """Extract DEPL and SIEF fields for all time steps."""
+        print("\nExtracting fields...")
+        self.fields = FieldExtractor(self.reader)
+        self.fields.extract()
+        print(f"  Stress mode: {self.fields.stress_mode}")
+        print(f"  Time steps:  {self.fields.n_timesteps}")
+
+    def step_4_load_shell_metadata(self):
+        """Load REPLO/CARCOQUE: embedded first, then separate file as fallback."""
+        print("\nLoading shell metadata (REPLO, CARCOQUE)...")
+        self.shell_meta = ShellMetadata()
+        loaded = self.shell_meta.load(self.reader, self.orientation_med_filename)
+        if loaded:
+            print(f"  Loaded from: {self.shell_meta.source}")
+            if self.shell_meta.replo1 is not None:
+                print(f"  REPLO_1: {len(self.shell_meta.replo1)} entries")
+            if self.shell_meta.carcoque_ep is not None:
+                uniq = sorted({round(float(v), 3) for v in self.shell_meta.carcoque_ep})
+                print(f"  CARCOQUE EP unique values: {uniq}")
+        else:
+            print("  No shell metadata available (using defaults)")
+
+    def step_5_filter(self):
+        """Reduce model to active groups and map shell metadata."""
+        print("\nFiltering active data...")
+        self.filter = ActiveFilter(
+            self.mesh, self.shell_meta,
+            requested_groups=self.active_groups,
+            requested_nsets=self.active_nsets,
+        )
+        self.filter.apply()
+        print(f"  Active elements: {len(self.filter.active_elem_ids)}")
+        print(f"  Active nodes:    {len(self.filter.active_node_ids)}")
+
+    def step_6_write(self):
+        """Write the .linp and .lui output files."""
+        LinpWriter(self.mesh, self.filter, self.med_filename).write(self.linp_filename)
+        LuiWriter(self.mesh, self.filter, self.fields, self.med_filename).write(self.lui_filename)
+
+    # --------------------------------------------------------------- full
+
+    def convert(self):
+        """Run the complete pipeline."""
+        try:
+            self.step_1_load()
+            self.step_2_extract_mesh()
+            self.step_3_extract_fields()
+            self.step_4_load_shell_metadata()
+            self.step_5_filter()
+            self.step_6_write()
+            print("\n" + "=" * 60)
+            print("Translation complete")
+            print("=" * 60)
+            return True
+        except Exception as e:
+            import traceback
+            print(f"\nERROR: Conversion failed: {e}")
+            print(traceback.format_exc())
+            return False

med2limit/element_types.py

@@ -0,0 +1,80 @@
+"""
+MED ↔ LIMIT element type mapping and classification helpers.
+
+This module is pure: no I/O, no MEDCoupling reads. Only mapping tables and
+small functions. Easy to test in isolation.
+"""
+
+import medcoupling as mc
+
+
+# Mapping from MEDCoupling geometric type codes to LIMIT/Abaqus element type names.
+MED_TO_LIMIT = {
+    # Solids
+    mc.NORM_HEXA8: "C3D8",
+    mc.NORM_HEXA20: "C3D20",
+    mc.NORM_TETRA4: "C3D4",
+    mc.NORM_TETRA10: "C3D10",
+    mc.NORM_PENTA6: "C3D6",
+    mc.NORM_PENTA15: "C3D15",
+    # Shells / 2D
+    mc.NORM_TRI3: "S3",
+    mc.NORM_QUAD4: "S4",
+    mc.NORM_TRI6: "STRI65",
+    mc.NORM_QUAD8: "S8R",
+    # Beams / 1D
+    mc.NORM_SEG2: "T3D2",
+    mc.NORM_SEG3: "B32",
+}
+
+
+# Validated MED → LIMIT local-node permutations for linear 3D solids.
+# Identified by direct LIMIT_CAE geometry tests.
+NODE_REORDER = {
+    "C3D8": [0, 3, 2, 1, 4, 7, 6, 5],
+    "C3D6": [0, 2, 1, 3, 5, 4],
+}
+
+
+def med_to_limit(geo_type):
+    """Return the LIMIT name for a MEDCoupling geometric type, or a placeholder."""
+    return MED_TO_LIMIT.get(geo_type, f"UNKNOWN_{geo_type}")
+
+
+def is_shell(elem_type: str) -> bool:
+    """True for shell-like element types handled by this tool."""
+    return elem_type.startswith("S") or elem_type.startswith("M")
+
+
+def is_solid(elem_type: str) -> bool:
+    """True for 3D solid element types."""
+    return elem_type.startswith("C3D")
+
+
+def is_beam_or_truss(elem_type: str) -> bool:
+    """True for 1D beam/truss element types."""
+    return elem_type.startswith("T3D") or elem_type.startswith("B")
+
+
+def is_result_carrying(elem_type: str) -> bool:
+    """True for element types that carry stress/displacement results in LIMIT."""
+    return is_shell(elem_type) or is_solid(elem_type)
+
+
+def get_reorder_indices(elem_type: str, n_nodes: int):
+    """Return the validated MED→LIMIT local-node permutation, or identity."""
+    perm = NODE_REORDER.get(elem_type)
+    if perm is None or len(perm) != n_nodes:
+        return list(range(n_nodes))
+    return perm
+
+
+def reorder_connectivity(elem_type: str, connectivity):
+    """Reorder a connectivity list with the validated MED→LIMIT permutation."""
+    order = get_reorder_indices(elem_type, len(connectivity))
+    return [connectivity[i] for i in order]
+
+
+def clean_name(name) -> str:
+    """Normalize a group name by removing underscores (LIMIT naming convention)."""
+    return str(name).replace("_", "")

med2limit/fields.py

@@ -0,0 +1,108 @@
+"""
+Field extraction: displacement (DEPL) and stress (SIEF).
+
+Two stress modes are detected automatically:
+- 'shell_top_bottom' — SIEF_INF + SIEF_SUP (shell top/bottom faces)
+- 'generic'          — SIEF_ELNO (solid or generic ELNO stress)
+
+All time steps are extracted at once. Per-step mapping to per-element data
+happens later in writer.py / filter.py.
+"""
+
+
+class FieldExtractor:
+    """Extract raw displacement and stress arrays for every time step.
+
+    Outputs after `extract()`:
+    - n_timesteps:           int
+    - stress_mode:           'shell_top_bottom' | 'generic' | None
+    - disp_raw_ts:           list of ndarray  (one per timestep)
+    - stress_inf_raw_ts:     list of ndarray | None  (only if shell mode)
+    - stress_sup_raw_ts:     list of ndarray | None  (only if shell mode)
+    - stress_generic_raw_ts: list of ndarray | None  (only if generic mode)
+    """
+
+    def __init__(self, reader):
+        self.reader = reader
+        self.n_timesteps = 0
+        self.stress_mode = None
+        self.disp_raw_ts = []
+        self.stress_inf_raw_ts = []
+        self.stress_sup_raw_ts = []
+        self.stress_generic_raw_ts = []
+
+    def extract(self):
+        disp_field = self._find_displacement_field()
+        if disp_field is None:
+            raise RuntimeError("No displacement field found (DEPL). Cannot proceed.")
+
+        stress_inf_field = self.reader.find_field("SIEF_INFSIEF_ELNO")
+        stress_sup_field = self.reader.find_field("SIEF_SUPSIEF_ELNO")
+        stress_generic_field = self.reader.find_field(
+            "SIEF_ELNO", exclude=("INF", "SUP")
+        )
+
+        # Track what's available — they're not mutually exclusive anymore
+        self.has_shell_stress = (stress_inf_field is not None and stress_sup_field is not None)
+        self.has_generic_stress = stress_generic_field is not None
+
+        # Legacy flag for backward compat (e.g. logging)
+        if self.has_shell_stress and self.has_generic_stress:
+            self.stress_mode = "mixed"
+        elif self.has_shell_stress:
+            self.stress_mode = "shell_top_bottom"
+        elif self.has_generic_stress:
+            self.stress_mode = "generic"
+        else:
+            self.stress_mode = None
+
+        self.n_timesteps = disp_field.getNumberOfTS()
+        self.disp_raw_ts = [None] * self.n_timesteps
+        self.stress_inf_raw_ts = [None] * self.n_timesteps
+        self.stress_sup_raw_ts = [None] * self.n_timesteps
+        self.stress_generic_raw_ts = [None] * self.n_timesteps
+
+        for it in range(self.n_timesteps):
+            self._extract_one_step(
+                it, disp_field, stress_inf_field, stress_sup_field, stress_generic_field
+            )
+
+    def _find_displacement_field(self):
+        """Find a field whose name contains DEPL (e.g., RESU____DEPL)."""
+        for field in self.reader.fields:
+            if "DEPL" in field.getName():
+                return field
+        return None
+
+    def _extract_one_step(self, it, disp_field, inf_field, sup_field, gen_field):
+        # Displacement
+        try:
+            self.disp_raw_ts[it] = (
+                disp_field.getTimeStepAtPos(it).getUndergroundDataArray().toNumPyArray()
+            )
+        except Exception as e:
+            print(f"  WARNING: TS={it}: could not extract displacement: {e}")
+    
+        # Generic stress (for solids) — independent of shell stress
+        if self.has_generic_stress:
+            try:
+                self.stress_generic_raw_ts[it] = (
+                    gen_field.getTimeStepAtPos(it).getUndergroundDataArray().toNumPyArray()
+                )
+            except Exception as e:
+                print(f"  WARNING: TS={it}: could not extract generic stress: {e}")
+    
+        # Shell top/bottom (for shells) — independent of generic stress
+        if self.has_shell_stress:
+            try:
+                self.stress_inf_raw_ts[it] = (
+                    inf_field.getTimeStepAtPos(it).getUndergroundDataArray().toNumPyArray()
+                )
+            except Exception as e:
+                print(f"  WARNING: TS={it}: could not extract stress_inf: {e}")
+            try:
+                self.stress_sup_raw_ts[it] = (
+                    sup_field.getTimeStepAtPos(it).getUndergroundDataArray().toNumPyArray()
+                )
+            except Exception as e:
+                print(f"  WARNING: TS={it}: could not extract stress_sup: {e}")

med2limit/filter.py

@@ -0,0 +1,144 @@
+"""
+Active filter: select element groups to export and trim everything else.
+
+Also applies shell metadata (orientations and thickness) to the active
+shell elements by geometric signature lookup.
+"""
+
+from .element_types import is_shell, is_solid
+from .orientation import build_active_shell_signatures
+
+
+class ActiveFilter:
+    """Reduce the model to a chosen subset of element groups.
+
+    After `apply()`:
+    - mesh.all_elements / all_nodes / element_sets / node_sets are filtered in place
+    - active_elem_ids:    set[int]
+    - active_node_ids:    set[int]
+    - shell_orientations: {elem_id: (D1, D2)}  (only mapped shells)
+    - shell_thickness:    {elem_id: float}     (only mapped shells)
+    - has_shell_elements / has_solid_elements: bool
+    """
+
+    def __init__(self, mesh, shell_metadata, requested_groups=None, requested_nsets=None):
+        self.mesh = mesh
+        self.shell_metadata = shell_metadata
+        self.requested_groups = set(requested_groups or [])
+        self.requested_nsets = set(requested_nsets or [])
+
+        self.active_elem_ids = set()
+        self.active_node_ids = set()
+        self.shell_orientations = {}
+        self.shell_thickness = {}
+        self.has_shell_elements = False
+        self.has_solid_elements = False
+
+    # ------------------------------------------------------------------ public
+
+    def apply(self):
+        selected = self._select_group_names()
+        self._trim_elements_and_nodes(selected)
+        self._trim_node_sets()
+        self._compute_capability_flags()
+        self._map_shell_metadata()
+
+    # ----------------------------------------------------------------- private
+
+    def _select_group_names(self):
+        """Pick the set of element-group names to keep.
+
+        Priority:
+        1. Explicit requested_groups (if any names match)
+        2. User-defined GROUP_MA names extracted by the mesh
+        3. All solid-only sets if the model contains solids
+        4. Otherwise all shell sets
+        """
+        es = self.mesh.element_sets
+
+        if self.requested_groups:
+            selected = {name for name in es if name in self.requested_groups}
+            if selected:
+                return selected
+            print("  WARNING: requested active groups not found — falling back to auto selection")
+
+        if self.mesh.user_element_group_names:
+            return set(self.mesh.user_element_group_names)
+
+        all_types = {e["type"] for e in self.mesh.all_elements.values()}
+        if any(is_solid(t) for t in all_types):
+            return {name for name, d in es.items() if is_solid(d["type"])}
+        return {name for name, d in es.items() if is_shell(d["type"])}
+
+    def _trim_elements_and_nodes(self, selected_names):
+        active_elem_ids = set()
+        kept_sets = {}
+        for name, data in self.mesh.element_sets.items():
+            if name not in selected_names:
+                continue
+            ids = [eid for eid in data["elements"] if eid in self.mesh.all_elements]
+            if not ids:
+                continue
+            kept_sets[name] = {"type": data["type"], "elements": ids}
+            active_elem_ids.update(ids)
+
+        if not active_elem_ids:
+            raise RuntimeError(
+                "No active elements selected. Check element group names or model contents."
+            )
+
+        self.mesh.element_sets = kept_sets
+        self.mesh.all_elements = {
+            eid: d for eid, d in self.mesh.all_elements.items() if eid in active_elem_ids
+        }
+
+        active_node_ids = set()
+        for elem in self.mesh.all_elements.values():
+            active_node_ids.update(elem["connectivity"])
+        self.mesh.all_nodes = {
+            nid: c for nid, c in self.mesh.all_nodes.items() if nid in active_node_ids
+        }
+
+        self.active_elem_ids = active_elem_ids
+        self.active_node_ids = active_node_ids
+
+    def _trim_node_sets(self):
+        if self.requested_nsets:
+            self.mesh.node_sets = {
+                name: ids for name, ids in self.mesh.node_sets.items()
+                if name in self.requested_nsets
+            }
+        else:
+            # Keep only nodes that survived the element filter
+            self.mesh.node_sets = {
+                name: [nid for nid in ids if nid in self.active_node_ids]
+                for name, ids in self.mesh.node_sets.items()
+            }
+            self.mesh.node_sets = {n: ids for n, ids in self.mesh.node_sets.items() if ids}
+
+    def _compute_capability_flags(self):
+        types = {d["type"] for d in self.mesh.all_elements.values()}
+        self.has_shell_elements = any(is_shell(t) for t in types)
+        self.has_solid_elements = any(is_solid(t) for t in types)
+
+    def _map_shell_metadata(self):
+        if not self.has_shell_elements or self.shell_metadata is None:
+            return
+
+        sigs = build_active_shell_signatures(self.mesh.all_nodes, self.mesh.all_elements)
+        if not sigs:
+            return
+
+        n_orient = 0
+        n_thick = 0
+        for elem_id, _sig in sigs.items():
+            ori = self.shell_metadata.get_orientation(elem_id, sigs)
+            if ori is not None:
+                self.shell_orientations[elem_id] = ori
+                n_orient += 1
+            thick = self.shell_metadata.get_thickness(elem_id, sigs)
+            if thick is not None:
+                self.shell_thickness[elem_id] = thick
+                n_thick += 1
+
+        print(f"  Mapped {n_orient} shell orientations and {n_thick} shell thicknesses")