pymats 0.1.0__py3-none-any.whl

cae/__init__.py

@@ -0,0 +1,42 @@
+import numpy as np
+from typing import Optional, Literal
+from pymats import MaterialBase
+from pymats.cae.constitutive import ConstitutiveModel, IsotropicModel
+from pymats.cae.stressstraincurve import StressStrainCurve, ModelConstants
+
+class CAEModel:
+    
+    material: MaterialBase
+
+    def __init__(self, material: MaterialBase) -> None:
+        self.material = material
+
+    
+    def get_stress_strain_curve(self, approach: ModelConstants.Approaches) -> StressStrainCurve:
+        a_s = self.material.ElongationBreak.long if self.material.ElongationBreak else 0.12
+        if np.isclose(a_s, 0.0):
+            a_s = 1.2
+        curve = StressStrainCurve(
+            Model=approach, 
+            youngs_modulus=self.material.EO,
+            yield_strength=self.material.SYo,
+            tensile_strength=self.material.STo,
+            elongation_at_break=a_s
+        )
+        curve.attach_material(self.material)
+        curve.build()
+        return curve
+    
+
+    def get_constitutive_model(
+            self, d: Optional[np.ndarray] = None,
+            kinematics: Literal['full', 'axissymmetric', 'plane strain', 'plane stress'] = 'full'
+        ) -> ConstitutiveModel:
+        return IsotropicModel(
+            d or IsotropicModel.compute_d(
+                self.material.EO,
+                self.material.PoissonsRatio,
+                kinematics
+            ), 
+            self.material.EO, self.material.PoissonsRatio
+        )

cae/constitutive.py

@@ -0,0 +1,127 @@
+from typing import Literal
+import numpy as np
+from abc import ABC, abstractmethod
+
+
+class Plasticity:
+
+    tangent_modulus: float = 203e3
+    @property
+    def H(self):
+        return self.tangent_modulus
+
+    def __init__(self, e: float) -> None:
+        # initalized with tangent modulus as youngs modulus for no plasticity
+        self.tangent_modulus = e
+
+    
+
+class ConstitutiveModel(ABC):
+
+    plasticity: Plasticity
+
+    _d: np.ndarray
+    @property
+    def D(self):
+        return self._d
+
+    @classmethod
+    @abstractmethod
+    def compute_d(cls, *args, **kwargs) -> np.ndarray:
+        pass
+
+    def __init__(self, d: np.ndarray, e: float, nu: float) -> None:
+        super().__init__()
+        self._d = d
+        self.plasticity = Plasticity(e)
+
+    def compute_elastic_stress(self, eps: np.ndarray):
+        return self._d @ eps
+
+    def set_plastiticity(
+            self, 
+            plasticity: Literal['linear hardening' ,'perfect'],
+            sy: float,
+            st: float,
+            e: float,
+            a_s: float
+        ):
+        if plasticity == 'perfect':
+            self.plasticity.tangent_modulus = 0.0
+        elif plasticity == 'linear hardening':
+            eps_el = sy / e
+            eps_pl = a_s - eps_el
+            ds = st - sy
+            self.plasticity.tangent_modulus = ds / eps_pl
+
+class IsotropicModel(ConstitutiveModel):
+
+    # lame parameters
+    mu: float
+    lam: float
+    # ##################
+    
+
+    @classmethod
+    def compute_lame_parameters(cls, e, nu):
+        mu = e / (2 * (1 + nu))
+        lam = e * nu / ((1 + nu) * (1 - 2 * nu))
+        return mu, lam
+    
+    @classmethod
+    def compute_axissymmetric_stiffness(cls, e: float, nu: float):
+        c = e / ((1 + nu) * (1 - 2 * nu))
+        return c * np.array([
+            [1 - nu, nu, nu, 0],
+            [nu, 1 - nu, nu, 0],
+            [nu, nu, 1 - nu, 0],
+            [0, 0, 0, (1 - 2 * nu) / 2]
+        ])
+
+    @classmethod
+    def compute_plane_strain_stiffness(cls, e: float, nu: float):
+        c = e / ((1 + nu) * (1 - 2 * nu))
+        return c * np.array([
+            [1 - nu, nu, 0],
+            [nu, 1 - nu, 0],
+            [0, 0, (1 - 2 * nu) / 2.0]
+        ])
+
+    @classmethod
+    def compute_plane_stress_stiffness(cls, e: float, nu: float):
+        c = e / (1 - nu **2)
+        return c * np.array([
+            [1, nu, 0],
+            [nu, 1, 0],
+            [0, 0, (1 - nu) / 2]
+        ])
+    
+    @classmethod
+    def compute_full_stiffness(cls, e: float, nu: float):
+        mu, lam = cls.compute_lame_parameters(e, nu)
+        d = np.zeros((6, 6))
+        d[:3, :3] = lam
+        np.fill_diagonal(d[:3, :3], lam + 2 * mu)
+        d[3:, 3:] = np.eye(3) * mu
+        return d
+
+    @classmethod
+    def compute_d(cls, e: float, nu: float, kinematics: Literal['full', 'plane strain', 'plane stress', 'axissymmetric']) -> np.ndarray:
+        
+        if kinematics == 'axissymmetric':
+            d = cls.compute_axissymmetric_stiffness(e, nu)
+        elif kinematics == 'plane strain':
+            d = cls.compute_plane_strain_stiffness(e, nu)
+        elif kinematics == 'plane stress':
+            d = cls.compute_plane_stress_stiffness(e, nu)
+        elif kinematics == 'full':
+            d = cls.compute_full_stiffness(e, nu)
+        else:
+            raise ValueError("Don't understand kinematic requirement!")
+        return d
+
+
+    def __init__(self, d: np.ndarray, e: float, nu: float) -> None:
+        super().__init__(d, e, nu)
+        self.mu, self.lam = self.compute_lame_parameters(e, nu)
+    

cae/stressstraincurve.py

@@ -0,0 +1,156 @@
+import numpy as np
+from typing import Optional
+
+from pydantic import computed_field, PrivateAttr
+
+from pymats.utils.log import logger
+from enum import Enum
+from pymats.utils.mbasemodel import MBaseModel
+from pymats import MaterialBase
+
+
+class ModelConstants:
+    class Approaches(str, Enum):
+        LINEARELASTIC = "linearelastic"
+        PERFECTPLASTICITY = "perfectplastic"
+        LINEARHARDENING = "linearhardening"
+
+class StressStrainCurve(MBaseModel):
+
+    _data: np.ndarray = PrivateAttr(default=np.array((2, 2)))
+    _material: MaterialBase | None = PrivateAttr(default=None)
+    @computed_field(return_type=np.ndarray)
+    @property
+    def Data(self):
+        return self._data
+    Model: ModelConstants.Approaches
+    
+    # material properties
+    youngs_modulus: float
+    yield_strength: float
+    tensile_strength: float
+    elongation_at_break: float
+
+    def attach_material(self, material: MaterialBase) -> None:
+        self._material = material
+
+    def get_elastic_strain(self) -> float:
+        if not self._material:
+            raise ValueError("Material not attached to stress-strain curve.")
+        if not np.isclose(self._material.EO, 0.0):
+            return self._material.SYo / self._material.EO
+        raise ZeroDivisionError("The Young's modulus is zero! Check material data.")
+
+    def get_ansys_model(self) -> str:
+        if not self._material:
+            raise ValueError("Material not attached to stress-strain curve.")
+        lines = [
+            "/PREP7",
+            f"! Material {self._material.Synopsis} properties",
+            f"MP, EX, {self._material.MID}, {self._material.EO}",
+            f"MP, PRXY, {self._material.MID}, {self._material.PoissonsRatio}",
+            f"MP, DENS, {self._material.MID}, {self._material.Density}",
+        ]
+
+        if self.Model in [ModelConstants.Approaches.LINEARHARDENING, ModelConstants.Approaches.PERFECTPLASTICITY]:
+            hardening_modulus = 0.0
+            if self.Model == ModelConstants.Approaches.LINEARHARDENING:
+                a_s = self._material.ElongationBreak.long if self._material.ElongationBreak else 0.12
+                eps_el = self.get_elastic_strain()
+                hardening_modulus = (self._material.STo - self._material.SYo) / (a_s - eps_el)
+
+            lines.extend([
+                "! Plasticity with isotropic hardening",
+                f"TB, PLASTIC, {self._material.MID}, 1, 1",
+                f"TBPT, 1, {self._material.SYo}, {hardening_modulus}"
+            ])
+
+        lines.append("/FINISH")
+        return "\n".join(lines)
+
+    def get_dyna_model(self) -> str:
+        if not self._material:
+            raise ValueError("Material not attached to stress-strain curve.")
+        lines = ["*KEYWORD"]
+        args = ["MID", "RO", "E", "PR"]
+        values = [self._material.MID, self._material.Density, self._material.EO, self._material.PoissonsRatio]
+
+        if self.Model == ModelConstants.Approaches.LINEARELASTIC:
+            lines.append("*MAT_ELASTIC")
+        else:
+            lines.append("*MAT_PIECEWISE_LINEAR_PLASTICITY")
+            args.extend(["SIGY", "ETAN", "FAIL", "TDEL"])
+            values.extend([self._material.SYo, 0.0, 0.0, 0.0])
+
+        lines.append("$ " + "\t".join(args))
+        lines.append("\t".join(map(str, values)))
+
+        if self.Model != ModelConstants.Approaches.LINEARELASTIC:
+            hardening_stress = self._material.STo if self.Model == ModelConstants.Approaches.LINEARHARDENING else self._material.SYo
+            lines.extend([
+                "$ Epsilon-Plastic Strain vs. Stress Data",
+                "$ EPS\tSIG",
+                f"0.0\t{self._material.SYo}",
+                f"{self._material.ElongationBreak}\t{hardening_stress}"
+            ])
+
+        lines.append("*END")
+        return "\n".join(lines)
+
+    def get_abaqus_model(self) -> str:
+        if not self._material:
+            raise ValueError("Material not attached to stress-strain curve.")
+        lines = [
+            f"*Material, NAME={self._material.Synopsis}",
+            "*DENSITY",
+            f"{self._material.Density}",
+            "*ELASTIC",
+            f"{self._material.EO}, {self._material.PoissonsRatio}"
+        ]
+
+        if self.Model != ModelConstants.Approaches.LINEARELASTIC:
+            lines.extend([
+                "*PLASTIC",
+                f"{self._material.SYo}, 0.0",
+                f"{self._material.STo}, {self._material.ElongationBreak}"
+            ])
+
+        return "\n".join(lines)
+
+    def _build_linear_elastic(self):
+        self._data = np.array([
+            [0, 0],
+            [self.yield_strength / self.youngs_modulus, self.yield_strength]
+        ])
+
+    def _build_perfect_plasticity(self):
+        self._data = np.array([
+            [0, 0],
+            [self.yield_strength / self.youngs_modulus, self.yield_strength],
+            [0.3, self.yield_strength]
+        ])
+
+    def _build_linear_plasticity(self):
+        self._data = np.array([
+            [0, 0],
+            [self.yield_strength / self.youngs_modulus, self.yield_strength],
+            [self.elongation_at_break, self.tensile_strength]
+        ])
+
+    def add_material_properties(self, *args):
+        self.youngs_modulus, self.yield_strength, self.tensile_strength, self.elongation_at_break = args
+
+    def reset(self):
+        self._data = np.zeros((2, 2))
+
+    def build(self):
+        try:
+            if self.Model == ModelConstants.Approaches.LINEARELASTIC:
+                self._build_linear_elastic()
+            elif self.Model == ModelConstants.Approaches.PERFECTPLASTICITY:
+                self._build_perfect_plasticity()
+            elif self.Model == ModelConstants.Approaches.LINEARHARDENING:
+                self._build_linear_plasticity()
+        except ZeroDivisionError:
+            logger.warning("Division by zero error!")
+            return

data/__init__.py

@@ -0,0 +1,7 @@
+from typing import List
+from pymats.data.loader import LoaderFactory, MaterialIndex
+
+
+def get_mids(query: str | None = None) -> List[MaterialIndex]:
+    loader = LoaderFactory.get_loader()   
+    return loader.get_identifiers(query=query)

data/collection.py

@@ -0,0 +1,100 @@
+import numpy as np
+import pandas as pd
+from typing import List, Union, Set, Type
+from sklearn.metrics.pairwise import cosine_similarity
+
+from pydantic import PrivateAttr, computed_field, SerializeAsAny
+
+from pymats.materials.asmematerial import ASMEMaterial
+from pymats.materials.enmaterial import ENMaterial
+from pymats.materials.materialbase import MaterialBase
+from pymats.materials.constants import MaterialDataConstants
+from pymats.data.loader import MaterialLoaderBase
+from pymats import Material, MaterialFactory
+from pymats.utils.log import logger
+from pymats.config import settings
+from pymats.utils.mbasemodel import MBaseModel
+
+class MaterialCollection(MBaseModel):
+
+    CollectionName: str
+    IsCustomCollection: bool = False
+    materials: list[SerializeAsAny[MaterialBase]] = []
+
+    @classmethod
+    def load_from_db(
+        cls,
+        handler: MaterialLoaderBase,
+        collection_name: str,
+        identifiers: list[str] = [],
+        include_property_data: bool = True
+    ) -> "MaterialCollection":
+        
+        is_custom = collection_name in settings.CustomCollectionNames
+
+        docs = handler.load_collection_materials(
+            collection_name,
+            material_names=identifiers,
+            include_property_data=include_property_data
+        )
+        materials = []
+        for doc in docs.values():
+            try:
+                materials.append(
+                    MaterialFactory.from_data(doc, init_mech_properties=False)
+                )
+            except Exception as ex:
+                name = doc.get('Name', 'none')
+                logger.warning(f'Failed to load material {str(name)} for collection {str(collection_name)} with {str(ex)}')
+                continue
+        return cls(CollectionName=collection_name, IsCustomCollection=is_custom, materials=materials)
+        
+    @computed_field(return_type=list[str])
+    @property
+    def Keys(self):
+        if len(self.materials) > 0:
+            class_t = self.materials[0].__class__
+        else:
+            class_t = Material
+        return list(class_t.model_fields.keys())
+
+
+    def is_standard_collection(self) -> bool:
+        """
+        Check if the collection is a standard collection (ASME, EN).
+        
+        Returns:
+            bool: True if the collection is a standard collection, False otherwise.
+        """
+        return self.CollectionName in MaterialDataConstants.Collections.__members__.values()
+    
+    def find_equivalents(self, material: MaterialBase, tolerance: float = 0.0):
+        master = material.tokenize(20 ,0)
+        for mat in self.materials:
+            try:
+                if mat.Identifier == material.Identifier:
+                    continue
+                candidate = mat.tokenize(20, 0)
+                sim = cosine_similarity(master.reshape(1, -1), candidate.reshape(1, -1))
+                # euclidean = np.linalg.norm(master.reshape(1, -1) - candidate.reshape(1, -1))
+                if np.max(sim) >= tolerance:
+                    yield (mat, np.max(sim))
+            except Exception as e:
+                logger.error(f"Failed to compare materials: {e}")
+                continue
+    
+    def get_equivalents(self, material: MaterialBase, tolerance: float = 0.0):
+        equivalents = []
+        for mat in self.find_equivalents(material, tolerance):
+            material, sim = mat
+            equivalents.append({
+                "material": material.Synopsis,
+                "standard": material.Standards,
+                "score": sim
+            })
+        df = pd.DataFrame(equivalents)
+        df.sort_values(by="score", ascending=False, inplace=True)  
+        df.reset_index(drop=True, inplace=True)
+        df = df.iloc[:10, :]
+        return df.to_dict(orient="records")
+