med2limit 0.0.1__tar.gz

med2limit-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 simvia-tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

med2limit-0.0.1/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: med2limit
+Version: 0.0.1
+Summary: Convert Code_Aster MED/RMED simulation files to LIMIT .linp / .lui input format
+Author-email: Dorian Nezzar <dorian.nezzar@simvia.tech>
+License-Expression: MIT
+Keywords: med,rmed,code_aster,limit,fea,fatigue
+Requires-Python: <=3.13,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: medcoupling>=9.15
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+<p align="center"><img src="logo/logo_med_coupling.png" alt="logo" width="50%"></p>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# med2limit
+Convert Code_Aster MED/RMED simulation results into LIMIT `.linp` / `.lui` input files for fatigue analysis.
+
+## Features
+
+- Shell workflows (DKT elements: S3, S4) with REPLO/CARCOQUE handling
+- Linear solid workflows (C3D8 / HEXA8, C3D6 / PENTA6) with validated LIMIT node ordering
+- Multi-step / multi-increment displacement and stress transfer
+- Optional shell orientation file, or read directly from `IMPR_CONCEPT`-embedded result file
+- Automatic detection of shell support level (works for shell-only and mixed hexa+shell models)
+
+## Code_aster Requirement
+- Identify weld groups as Group_NO (not Group_MA), 1 node set per weld
+- For shell element, extract top/bottom stresses as:
+```bash
+SIEF_SUP=POST_CHAMP(RESULTAT=RESU,
+                    EXTR_COQUE=_F(NOM_CHAM='SIEF_ELNO',
+                                  NUME_COUCHE=1,
+                                  NIVE_COUCHE='SUP',),);
+
+SIEF_INF=POST_CHAMP(RESULTAT=RESU,
+                    EXTR_COQUE=_F(NOM_CHAM='SIEF_ELNO',
+                                  NUME_COUCHE=1,
+                                  NIVE_COUCHE='INF',),);
+```
+- For shell element, extract orientation/tichkness as:
+```bash
+IMPR_CONCEPT(FORMAT='MED',
+             UNITE=80, --> Same unit as your results or in a dedicated file
+             CONCEPT=(_F(CARA_ELEM=Elem,
+                         REPERE_LOCAL='ELEM',
+                         MODELE=Modell,),),)                                  
+```
+## Installation
+Install med2limit with pip into a virtual python environnement (venv):
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install git+https://github.com/simvia-tech/med2limit.git@dev
+```
+
+
+## Usage
+
+### Command line
+From 01_exemple in folder:
+```bash
+med2limit/exemples/data
+```
+
+```bash
+med2limit 01_exemple.rmed output.linp output.lui --groups "Shell1,Shell2" --nsets "WeldNo"
+```
+
+With separate orientation file:
+
+```bash
+med2limit 01_exemple.rmed output.linp output.lui 01_carcoc.rmed --groups "Shell1,Shell2" --nsets "WeldNo"
+```
+# 01_exemple
+<img src="./examples/images/01_exemple_LIMIT.png" width="50%">
+Code_aster Shell-Shell geometry successfully imported in LIMIT Software
+
+# 02_exemple
+<img src="./examples/images/02_exemple_LIMIT.png" width="50%">
+Code_aster Solid-Shell geometry successfully imported in LIMIT Software
+
+### Python API
+
+```python
+from med2limit import MEDToLimitConverter
+
+conv = MEDToLimitConverter(
+    med_filename="LIMIT1.rmed",
+    linp_filename="out.linp",
+    lui_filename="out.lui",
+    active_groups=["Shell1", "Shell2"],
+    active_nsets=["Weld"],
+)
+conv.convert()
+```
+
+## Package layout
+
+```
+med2limit/
+├── element_types.py   # MED↔LIMIT type mapping + helpers (pure)
+├── reader.py          # MED file open + field lookup
+├── mesh.py            # nodes, elements, GROUP_MA, GROUP_NO
+├── fields.py          # DEPL + SIEF over all timesteps
+├── orientation.py     # REPLO + CARCOQUE (embedded or separate)
+├── filter.py          # active group selection + shell metadata mapping
+├── result_mapper.py   # per-timestep stress/displacement mapping
+├── writer.py          # .linp + .lui output
+├── converter.py       # orchestrator (step_1 .. step_6 + convert)
+└── cli.py             # CLI + in-script config
+```
+
+## Testing
+
+```bash
+pytest                      # all tests
+pytest tests/test_element_types.py   # one module
+```
+
+## Known limitations
+
+- Quadratic solids (C3D10, C3D15, C3D20) — node ordering not yet validated in LIMIT
+- Shell elsets with mixed thicknesses use the most-frequent value (with warning)
+
+## Acknowledgments
+
+Special thanks to Tobias and Nikolaus for their feedback as early adopters
+and their patience during the iterative development of the converter.

med2limit-0.0.1/README.md

@@ -0,0 +1,119 @@
+<p align="center"><img src="logo/logo_med_coupling.png" alt="logo" width="50%"></p>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# med2limit
+Convert Code_Aster MED/RMED simulation results into LIMIT `.linp` / `.lui` input files for fatigue analysis.
+
+## Features
+
+- Shell workflows (DKT elements: S3, S4) with REPLO/CARCOQUE handling
+- Linear solid workflows (C3D8 / HEXA8, C3D6 / PENTA6) with validated LIMIT node ordering
+- Multi-step / multi-increment displacement and stress transfer
+- Optional shell orientation file, or read directly from `IMPR_CONCEPT`-embedded result file
+- Automatic detection of shell support level (works for shell-only and mixed hexa+shell models)
+
+## Code_aster Requirement
+- Identify weld groups as Group_NO (not Group_MA), 1 node set per weld
+- For shell element, extract top/bottom stresses as:
+```bash
+SIEF_SUP=POST_CHAMP(RESULTAT=RESU,
+                    EXTR_COQUE=_F(NOM_CHAM='SIEF_ELNO',
+                                  NUME_COUCHE=1,
+                                  NIVE_COUCHE='SUP',),);
+
+SIEF_INF=POST_CHAMP(RESULTAT=RESU,
+                    EXTR_COQUE=_F(NOM_CHAM='SIEF_ELNO',
+                                  NUME_COUCHE=1,
+                                  NIVE_COUCHE='INF',),);
+```
+- For shell element, extract orientation/tichkness as:
+```bash
+IMPR_CONCEPT(FORMAT='MED',
+             UNITE=80, --> Same unit as your results or in a dedicated file
+             CONCEPT=(_F(CARA_ELEM=Elem,
+                         REPERE_LOCAL='ELEM',
+                         MODELE=Modell,),),)                                  
+```
+## Installation
+Install med2limit with pip into a virtual python environnement (venv):
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install git+https://github.com/simvia-tech/med2limit.git@dev
+```
+
+
+## Usage
+
+### Command line
+From 01_exemple in folder:
+```bash
+med2limit/exemples/data
+```
+
+```bash
+med2limit 01_exemple.rmed output.linp output.lui --groups "Shell1,Shell2" --nsets "WeldNo"
+```
+
+With separate orientation file:
+
+```bash
+med2limit 01_exemple.rmed output.linp output.lui 01_carcoc.rmed --groups "Shell1,Shell2" --nsets "WeldNo"
+```
+# 01_exemple
+<img src="./examples/images/01_exemple_LIMIT.png" width="50%">
+Code_aster Shell-Shell geometry successfully imported in LIMIT Software
+
+# 02_exemple
+<img src="./examples/images/02_exemple_LIMIT.png" width="50%">
+Code_aster Solid-Shell geometry successfully imported in LIMIT Software
+
+### Python API
+
+```python
+from med2limit import MEDToLimitConverter
+
+conv = MEDToLimitConverter(
+    med_filename="LIMIT1.rmed",
+    linp_filename="out.linp",
+    lui_filename="out.lui",
+    active_groups=["Shell1", "Shell2"],
+    active_nsets=["Weld"],
+)
+conv.convert()
+```
+
+## Package layout
+
+```
+med2limit/
+├── element_types.py   # MED↔LIMIT type mapping + helpers (pure)
+├── reader.py          # MED file open + field lookup
+├── mesh.py            # nodes, elements, GROUP_MA, GROUP_NO
+├── fields.py          # DEPL + SIEF over all timesteps
+├── orientation.py     # REPLO + CARCOQUE (embedded or separate)
+├── filter.py          # active group selection + shell metadata mapping
+├── result_mapper.py   # per-timestep stress/displacement mapping
+├── writer.py          # .linp + .lui output
+├── converter.py       # orchestrator (step_1 .. step_6 + convert)
+└── cli.py             # CLI + in-script config
+```
+
+## Testing
+
+```bash
+pytest                      # all tests
+pytest tests/test_element_types.py   # one module
+```
+
+## Known limitations
+
+- Quadratic solids (C3D10, C3D15, C3D20) — node ordering not yet validated in LIMIT
+- Shell elsets with mixed thicknesses use the most-frequent value (with warning)
+
+## Acknowledgments
+
+Special thanks to Tobias and Nikolaus for their feedback as early adopters
+and their patience during the iterative development of the converter.

med2limit-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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("_", "")