pyedb 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

pyedb/dotnet/edb_core/materials.py

@@ -26,450 +26,523 @@ import difflib
 import logging
 import os
 import re
+from typing import Optional, Union
 import warnings
 
+from pydantic import BaseModel, confloat
+
+from pyedb import Edb
 from pyedb.dotnet.clr_module import _clr
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+from pyedb.exceptions import MaterialModelException
 from pyedb.generic.general_methods import is_ironpython, pyedb_function_handler
 
 logger = logging.getLogger(__name__)
 
+# TODO: Once we are Python3.9+ change PositiveInt implementation like
+# from annotated_types import Gt
+# from typing_extensions import Annotated
+# PositiveFloat = Annotated[float, Gt(0)]
+try:
+    from annotated_types import Gt
+    from typing_extensions import Annotated
+
+    PositiveFloat = Annotated[float, Gt(0)]
+except:
+    PositiveFloat = confloat(gt=0)
+
+ATTRIBUTES = [
+    "conductivity",
+    "dielectric_loss_tangent",
+    "magnetic_loss_tangent",
+    "mass_density",
+    "permittivity",
+    "permeability",
+    "poisson_ratio",
+    "specific_heat",
+    "thermal_conductivity",
+    "youngs_modulus",
+    "thermal_expansion_coefficient",
+]
+DC_ATTRIBUTES = [
+    "dielectric_model_frequency",
+    "loss_tangent_at_frequency",
+    "permittivity_at_frequency",
+    "dc_conductivity",
+    "dc_permittivity",
+]
+
+
+class MaterialProperties(BaseModel):
+    """Store material properties."""
+
+    conductivity: Optional[PositiveFloat] = None
+    dielectric_loss_tangent: Optional[PositiveFloat] = None
+    magnetic_loss_tangent: Optional[PositiveFloat] = None
+    mass_density: Optional[PositiveFloat] = None
+    permittivity: Optional[PositiveFloat] = None
+    permeability: Optional[PositiveFloat] = None
+    poisson_ratio: Optional[PositiveFloat] = None
+    specific_heat: Optional[PositiveFloat] = None
+    thermal_conductivity: Optional[PositiveFloat] = None
+    youngs_modulus: Optional[PositiveFloat] = None
+    thermal_expansion_coefficient: Optional[PositiveFloat] = None
+    dc_conductivity: Optional[PositiveFloat] = None
+    dc_permittivity: Optional[PositiveFloat] = None
+    dielectric_model_frequency: Optional[PositiveFloat] = None
+    loss_tangent_at_frequency: Optional[PositiveFloat] = None
+    permittivity_at_frequency: Optional[PositiveFloat] = None
+
 
 class Material(object):
-    """Manages EDB methods for material property management."""
-
-    def __init__(self, pclass, edb_material_def):
-        self._pclass = pclass
-        self._name = edb_material_def.GetName()
-        self._edb_material_def = edb_material_def
-        self._conductivity = 0.0
-        self._loss_tangent = 0.0
-        self._magnetic_loss_tangent = 0.0
-        self._mass_density = 0.0
-        self._permittivity = 0.0
-        self._permeability = 0.0
-        self._poisson_ratio = 0.0
-        self._specific_heat = 0.0
-        self._thermal_conductivity = 0.0
-        self._youngs_modulus = 0.0
-        self._thermal_expansion_coefficient = 0.0
-        self._dc_conductivity = 0.0
-        self._dc_permittivity = 0.0
-        self._dielectric_model_frequency = 0.0
-        self._loss_tangent_at_frequency = 0.0
-        self._permittivity_at_frequency = 0.0
-
-    def _edb_value(self, value):
-        return self._pclass._edb_value(value)
+    """Manage EDB methods for material property management."""
 
-    @property
-    def name(self):
-        """Retrieve material name."""
-        return self._name
+    def __init__(self, edb: Edb, material_def):
+        self.__edb: Edb = edb
+        self.__edb_definition = edb.edb_api.definition
+        self.__name: str = material_def.GetName()
+        self.__material_def = material_def
+        self.__dc_model = material_def.GetDielectricMaterialModel()
+        self.__properties: MaterialProperties = MaterialProperties()
 
     @property
-    def _db(self):
-        return self._pclass._db
+    def name(self):
+        """Material name."""
+        return self.__name
 
     @property
-    def _edb(self):
-        return self._pclass._edb
-
-    @pyedb_function_handler()
-    def _get_property(self, property_name):
-        if is_ironpython:  # pragma: no cover
-            property_box = _clr.StrongBox[float]()
-            self._edb_material_def.GetProperty(property_name, property_box)
-            return float(property_box)
-        else:
-            _, property_box = self._edb_material_def.GetProperty(property_name)
-            if isinstance(property_box, float):
-                return property_box
-            else:
-                return property_box.ToDouble()
+    def dc_model(self):
+        """Material dielectric model."""
+        return self.__dc_model
 
     @property
     def conductivity(self):
-        material_id = self._edb.definition.MaterialPropertyId.Conductivity
-        self._conductivity = self._get_property(material_id)
-        return self._conductivity
+        """Get material conductivity."""
+        if self.__properties.conductivity is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.Conductivity
+            self.__properties.conductivity = self.__property_value(material_property_id)
+        return self.__properties.conductivity
 
     @conductivity.setter
     def conductivity(self, value):
-        """Retrieve material conductivity."""
-        material_id = self._edb.definition.MaterialPropertyId.Conductivity
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._conductivity = value
+        """Set material conductivity."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.Conductivity
+        self.__material_def.SetProperty(material_property_id, self.__edb_value(value))
+        self.__properties.conductivity = edb_value.ToDouble()
 
     @property
     def permittivity(self):
-        """Retrieve material permittivity."""
-        material_id = self._edb.definition.MaterialPropertyId.Permittivity
-        self._permittivity = self._get_property(material_id)
-        return self._permittivity
+        """Get material permittivity."""
+        if self.__properties.permittivity is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.Permittivity
+            self.__properties.permittivity = self.__property_value(material_property_id)
+        return self.__properties.permittivity
 
     @permittivity.setter
     def permittivity(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.Permittivity
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._permittivity = value
+        """Set material permittivity."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.Permittivity
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.permittivity = edb_value.ToDouble()
 
     @property
     def permeability(self):
-        """Retrieve material permeability."""
-        material_id = self._edb.definition.MaterialPropertyId.Permeability
-        self._permeability = self._get_property(material_id)
-        return self._permeability
+        """Get material permeability."""
+        if self.__properties.permeability is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.Permeability
+            self.__properties.permeability = self.__property_value(material_property_id)
+        return self.__properties.permeability
 
     @permeability.setter
     def permeability(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.Permeability
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._permeability = value
+        """Set material permeability."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.Permeability
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.permeability = edb_value.ToDouble()
 
     @property
     def loss_tangent(self):
-        """Retrieve material loss tangent."""
-        material_id = self._edb.definition.MaterialPropertyId.DielectricLossTangent
-        self._loss_tangent = self._get_property(material_id)
-        return self._loss_tangent
+        """Get material loss tangent."""
+        warnings.warn(
+            "This method is deprecated in versions >0.7.0 and will soon be removed. "
+            "Use property dielectric_loss_tangent instead.",
+            DeprecationWarning,
+        )
+
+        return self.dielectric_loss_tangent
+
+    @property
+    def dielectric_loss_tangent(self):
+        """Get material loss tangent."""
+        if self.__properties.dielectric_loss_tangent is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
+            self.__properties.dielectric_loss_tangent = self.__property_value(material_property_id)
+        return self.__properties.dielectric_loss_tangent
 
     @loss_tangent.setter
     def loss_tangent(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.DielectricLossTangent
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._loss_tangent = value
+        """Set material loss tangent."""
+        warnings.warn(
+            "This method is deprecated in versions >0.7.0 and will soon be removed. "
+            "Use property dielectric_loss_tangent instead.",
+            DeprecationWarning,
+        )
+
+        return self.dielectric_loss_tangent(value)
+
+    @dielectric_loss_tangent.setter
+    def dielectric_loss_tangent(self, value):
+        """Set material loss tangent."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.dielectric_loss_tangent = edb_value.ToDouble()
 
     @property
     def dc_conductivity(self):
-        """"""
-        if self._edb_material_def.GetDielectricMaterialModel():
-            return self._edb_material_def.GetDielectricMaterialModel().GetDCConductivity()
+        """Get material dielectric conductivity."""
+        if self.__dc_model and self.__properties.dc_conductivity is None:
+            self.__properties.dc_conductivity = self.__dc_model.GetDCConductivity()
+        return self.__properties.dc_conductivity
 
     @dc_conductivity.setter
-    def dc_conductivity(self, value):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            self._edb_material_def.GetDielectricMaterialModel().SetDCConductivity(value)
+    def dc_conductivity(self, value: Union[int, float]):
+        """Set material dielectric conductivity."""
+        if self.__dc_model:
+            self.__dc_model.SetDCConductivity(value)
+            self.__properties.dc_conductivity = value
 
     @property
     def dc_permittivity(self):
-        """"""
-        if self._edb_material_def.GetDielectricMaterialModel():
-            return self._edb_material_def.GetDielectricMaterialModel().GetDCRelativePermitivity()
+        """Get material dielectric relative permittivity"""
+        if self.__dc_model and self.__properties.dc_permittivity is None:
+            self.__properties.dc_permittivity = self.__dc_model.GetDCRelativePermitivity()
+        return self.__properties.dc_permittivity
 
     @dc_permittivity.setter
-    def dc_permittivity(self, value):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            self._edb_material_def.GetDielectricMaterialModel().SetDCRelativePermitivity(value)
+    def dc_permittivity(self, value: Union[int, float]):
+        """Set material dielectric relative permittivity"""
+        if self.__dc_model:
+            self.__dc_model.SetDCRelativePermitivity(value)
+            self.__properties.dc_permittivity = value
 
     @property
     def dielectric_model_frequency(self):
-        """
-
-        Returns
-        -------
-        Frequency in GHz
-        """
-        if self._edb_material_def.GetDielectricMaterialModel():
-            return self._edb_material_def.GetDielectricMaterialModel().GetFrequency()
+        """Get material frequency in GHz."""
+        if self.__dc_model and self.__properties.dielectric_model_frequency is None:
+            self.__properties.dielectric_model_frequency = self.__dc_model.GetFrequency()
+        return self.__properties.dielectric_model_frequency
 
     @dielectric_model_frequency.setter
-    def dielectric_model_frequency(self, value):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            self._edb_material_def.GetDielectricMaterialModel().SetFrequency(value)
+    def dielectric_model_frequency(self, value: Union[int, float]):
+        """Get material frequency in GHz."""
+        if self.__dc_model:
+            self.__dc_model.SetFrequency(value)
+            self.__properties.dielectric_model_frequency = value
 
     @property
     def loss_tangent_at_frequency(self):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            return self._edb_material_def.GetDielectricMaterialModel().GetLossTangentAtFrequency()
+        """Get material loss tangeat at frequency."""
+        if self.__dc_model and self.__properties.loss_tangent_at_frequency is None:
+            self.__properties.loss_tangent_at_frequency = self.__dc_model.GetLossTangentAtFrequency()
+        return self.__properties.loss_tangent_at_frequency
 
     @loss_tangent_at_frequency.setter
     def loss_tangent_at_frequency(self, value):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            self._edb_material_def.GetDielectricMaterialModel().SetLossTangentAtFrequency(self._edb_value(value))
+        """Set material loss tangeat at frequency."""
+        if self.__dc_model:
+            edb_value = self.__edb_value(value)
+            self.__dc_model.SetLossTangentAtFrequency(edb_value)
+            self.__properties.dielectric_model_frequency = edb_value.ToDouble()
 
     @property
     def permittivity_at_frequency(self):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            return self._edb_material_def.GetDielectricMaterialModel().GetRelativePermitivityAtFrequency()
+        """Get material relative permittivity at frequency."""
+        if self.__dc_model and self.__properties.permittivity_at_frequency is None:
+            self.__properties.permittivity_at_frequency = self.__dc_model.GetRelativePermitivityAtFrequency()
+        return self.__properties.permittivity_at_frequency
 
     @permittivity_at_frequency.setter
-    def permittivity_at_frequency(self, value):
-        if self._edb_material_def.GetDielectricMaterialModel():
-            self._edb_material_def.GetDielectricMaterialModel().SetRelativePermitivityAtFrequency(value)
+    def permittivity_at_frequency(self, value: Union[int, float]):
+        """Set material relative permittivity at frequency."""
+        if self.__dc_model:
+            self.__dc_model.SetRelativePermitivityAtFrequency(value)
+            self.__properties.permittivity_at_frequency = value
 
     @property
     def magnetic_loss_tangent(self):
-        """Retrieve material magnetic loss tangent."""
-        material_id = self._edb.definition.MaterialPropertyId.MagneticLossTangent
-        self._magnetic_loss_tangent = self._get_property(material_id)
-        return self._magnetic_loss_tangent
+        """Get material magnetic loss tangent."""
+        if self.__properties.magnetic_loss_tangent is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.MagneticLossTangent
+            self.__properties.magnetic_loss_tangent = self.__property_value(material_property_id)
+        return self.__properties.magnetic_loss_tangent
 
     @magnetic_loss_tangent.setter
     def magnetic_loss_tangent(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.MagneticLossTangent
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._magnetic_loss_tangent = value
+        """Set material magnetic loss tangent."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.MagneticLossTangent
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.magnetic_loss_tangent = edb_value.ToDouble()
 
     @property
     def thermal_conductivity(self):
-        """Retrieve material thermal conductivity."""
-        material_id = self._edb.definition.MaterialPropertyId.ThermalConductivity
-        self._thermal_conductivity = self._get_property(material_id)
-        return self._thermal_conductivity
+        """Get material thermal conductivity."""
+        if self.__properties.thermal_conductivity is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.ThermalConductivity
+            self.__properties.thermal_conductivity = self.__property_value(material_property_id)
+        return self.__properties.thermal_conductivity
 
     @thermal_conductivity.setter
     def thermal_conductivity(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.ThermalConductivity
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._thermal_conductivity = value
+        """Set material thermal conductivity."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.ThermalConductivity
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.thermal_conductivity = edb_value.ToDouble()
 
     @property
     def mass_density(self):
-        """Retrieve material mass density."""
-        material_id = self._edb.definition.MaterialPropertyId.MassDensity
-        self._mass_density = self._get_property(material_id)
-        return self._mass_density
+        """Get material mass density."""
+        if self.__properties.thermal_conductivity is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.MassDensity
+            self.__properties.mass_density = self.__property_value(material_property_id)
+        return self.__properties.mass_density
 
     @mass_density.setter
     def mass_density(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.MassDensity
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._mass_density = value
+        """Set material mass density."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.MassDensity
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.mass_density = edb_value.ToDouble()
 
     @property
     def youngs_modulus(self):
-        """Retrieve material Young's Modulus."""
-        material_id = self._edb.definition.MaterialPropertyId.YoungsModulus
-        self._youngs_modulus = self._get_property(material_id)
-        return self._youngs_modulus
+        """Get material youngs modulus."""
+        if self.__properties.youngs_modulus is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.YoungsModulus
+            self.__properties.youngs_modulus = self.__property_value(material_property_id)
+        return self.__properties.youngs_modulus
 
     @youngs_modulus.setter
     def youngs_modulus(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.YoungsModulus
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._youngs_modulus = value
+        """Set material youngs modulus."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.YoungsModulus
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.youngs_modulus = edb_value.ToDouble()
 
     @property
     def specific_heat(self):
-        """Retrieve material Specific Heat."""
-        material_id = self._edb.definition.MaterialPropertyId.SpecificHeat
-        self._specific_heat = self._get_property(material_id)
-        return self._specific_heat
+        """Get material specific heat."""
+        if self.__properties.specific_heat is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.SpecificHeat
+            self.__properties.specific_heat = self.__property_value(material_property_id)
+        return self.__properties.specific_heat
 
     @specific_heat.setter
     def specific_heat(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.SpecificHeat
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._specific_heat = value
+        """Set material specific heat."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.SpecificHeat
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.specific_heat = edb_value.ToDouble()
 
     @property
     def poisson_ratio(self):
-        """Retrieve material Poisson Ratio."""
-        material_id = self._edb.definition.MaterialPropertyId.PoissonsRatio
-        self._poisson_ratio = self._get_property(material_id)
-        return self._poisson_ratio
+        """Get material poisson ratio."""
+        if self.__properties.specific_heat is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.PoissonsRatio
+            self.__properties.poisson_ratio = self.__property_value(material_property_id)
+        return self.__properties.poisson_ratio
 
     @poisson_ratio.setter
     def poisson_ratio(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.PoissonsRatio
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._poisson_ratio = value
+        """Set material poisson ratio."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.PoissonsRatio
+        self.__material_def.SetProperty(material_property_id, edb_value)
+        self.__properties.poisson_ratio = edb_value.ToDouble()
 
     @property
     def thermal_expansion_coefficient(self):
-        """Retrieve material Thermal Coefficient.."""
-        material_id = self._edb.definition.MaterialPropertyId.ThermalExpansionCoefficient
-        self._thermal_expansion_coefficient = self._get_property(material_id)
-        return self._thermal_expansion_coefficient
+        """Get material thermal coefficient."""
+        if self.__properties.thermal_expansion_coefficient is None:
+            material_property_id = self.__edb_definition.MaterialPropertyId.ThermalExpansionCoefficient
+            self.__properties.thermal_expansion_coefficient = self.__property_value(material_property_id)
+        return self.__properties.thermal_expansion_coefficient
 
     @thermal_expansion_coefficient.setter
     def thermal_expansion_coefficient(self, value):
-        material_id = self._edb.definition.MaterialPropertyId.ThermalExpansionCoefficient
-        self._edb_material_def.SetProperty(material_id, self._edb_value(value))
-        self._thermal_expansion_coefficient = value
+        """Set material thermal coefficient."""
+        edb_value = self.__edb_value(value)
+        material_property_id = self.__edb_definition.MaterialPropertyId.ThermalExpansionCoefficient
+        self.__material_def.SetProperty(material_property_id, self.__edb_value(value))
+        self.__properties.thermal_expansion_coefficient = edb_value.ToDouble()
 
     @pyedb_function_handler()
-    def _json_format(self):
-        out_dict = {}
-        if self.permittivity == 0:  # pragma no cover
-            self.permittivity = 1.0
-        if self.permeability == 0:  # pragma no cover
-            self.permeability = 1.0
-        self._name = self.name
-        self._conductivity = self.conductivity
-        self._loss_tangent = self.loss_tangent
-        self._magnetic_loss_tangent = self.magnetic_loss_tangent
-        self._mass_density = self.mass_density
-        self._permittivity = self.permittivity
-        self._permeability = self.permeability
-        self._poisson_ratio = self.poisson_ratio
-        self._specific_heat = self.specific_heat
-        self._thermal_conductivity = self.thermal_conductivity
-        self._youngs_modulus = self.youngs_modulus
-        self._thermal_expansion_coefficient = self.thermal_expansion_coefficient
-        self._dc_conductivity = self.dc_conductivity
-        self._dc_permittivity = self.dc_permittivity
-        self._dielectric_model_frequency = self.dielectric_model_frequency
-        self._loss_tangent_at_frequency = self.loss_tangent_at_frequency
-        self._permittivity_at_frequency = self.permittivity_at_frequency
-        for k, v in self.__dict__.items():
-            if not k == "_pclass" and not k == "_edb_material_def":
-                out_dict[k[1:]] = v
-        return out_dict
+    def to_dict(self):
+        """Convert material into dictionary."""
+        self.__load_all_properties()
+
+        res = {"name": self.name}
+        res.update(self.__properties.model_dump())
+        return res
 
     @pyedb_function_handler()
-    def _load(self, input_dict):
-        default_material = {
-            "name": "default",
-            "conductivity": 0,
-            "loss_tangent": 0,
-            "magnetic_loss_tangent": 0,
-            "mass_density": 0,
-            "permittivity": 1,
-            "permeability": 1,
-            "poisson_ratio": 0,
-            "specific_heat": 0,
-            "thermal_conductivity": 0,
-            "youngs_modulus": 0,
-            "thermal_expansion_coefficient": 0,
-            "dielectric_model_frequency": None,
-            "dc_permittivity": None,
-        }
+    def update(self, input_dict: dict):
         if input_dict:
-            for k, v in input_dict.items():
-                default_material[k] = v
-
-            self.conductivity = default_material["conductivity"]
-            self.loss_tangent = default_material["loss_tangent"]
-            self.magnetic_loss_tangent = default_material["magnetic_loss_tangent"]
-            self.mass_density = default_material["mass_density"]
-            self.permittivity = default_material["permittivity"]
-            self.permeability = default_material["permeability"]
-            self.poisson_ratio = default_material["poisson_ratio"]
-            self.specific_heat = default_material["specific_heat"]
-            self.thermal_conductivity = default_material["thermal_conductivity"]
-            self.youngs_modulus = default_material["youngs_modulus"]
-            self.thermal_expansion_coefficient = default_material["thermal_expansion_coefficient"]
-            if default_material["dielectric_model_frequency"] is not None:  # pragma: no cover
-                if self._edb_material_def.GetDielectricMaterialModel():
-                    model = self._edb_material_def.GetDielectricMaterialModel()
-                    self.dielectric_model_frequency = default_material["dielectric_model_frequency"]
-                    self.loss_tangent_at_frequency = default_material["loss_tangent_at_frequency"]
-                    self.permittivity_at_frequency = default_material["permittivity_at_frequency"]
-                    if default_material["dc_permittivity"] is not None:
-                        model.SetUseDCRelativePermitivity(True)
-                        self.dc_permittivity = default_material["dc_permittivity"]
-                    self.dc_conductivity = default_material["dc_conductivity"]
-                else:
-                    if not self._pclass.add_djordjevicsarkar_material(
-                        default_material["name"],
-                        default_material["permittivity_at_frequency"],
-                        default_material["loss_tangent_at_frequency"],
-                        default_material["dielectric_model_frequency"],
-                        default_material["dc_permittivity"],
-                        default_material["dc_conductivity"],
-                    ):
-                        self._pclass._pedb.logger.warning(
-                            'Cannot set DS model for material "{}". Check for realistic '
-                            "values that define DS Model".format(default_material["name"])
-                        )
+            # Update attributes
+            for attribute in ATTRIBUTES:
+                if attribute in input_dict:
+                    setattr(self, attribute, input_dict[attribute])
+            if "loss_tangent" in input_dict:
+                setattr(self, "loss_tangent", input_dict["loss_tangent"])
+
+            # Update DS model
+            # NOTE: Contrary to before we don't test 'dielectric_model_frequency' only
+            if any(map(lambda attribute: input_dict.get(attribute, None) is not None, DC_ATTRIBUTES)):
+                if not self.__dc_model:
+                    self.__dc_model = self.__edb_definition.DjordjecvicSarkarModel()
+                for attribute in DC_ATTRIBUTES:
+                    if attribute in input_dict:
+                        if attribute == "dc_permittivity" and input_dict[attribute] is not None:
+                            self.__dc_model.SetUseDCRelativePermitivity(True)
+                        setattr(self, attribute, input_dict[attribute])
+                self.__material_def.SetDielectricMaterialModel(self.__dc_model)
+            # Unset DS model if it is already assigned to the material in the database
+            elif self.__dc_model:
+                self.__material_def.SetDielectricMaterialModel(self.__edb_value(None))
+
+    @pyedb_function_handler()
+    def __edb_value(self, value):
+        """Convert a value to an EDB value.
+
+        Parameters
+        ----------
+        val : str, float, int
+        """
+        return self.__edb.edb_value(value)
+
+    @pyedb_function_handler()
+    def __load_all_properties(self):
+        """Load all properties of the material."""
+        for property in self.__properties.model_dump().keys():
+            _ = getattr(self, property)
+
+    @pyedb_function_handler()
+    def __property_value(self, material_property_id):
+        """Get property value from a material property id."""
+        if is_ironpython:  # pragma: no cover
+            property_box = _clr.StrongBox[float]()
+            self.__material_def.GetProperty(material_property_id, property_box)
+            return float(property_box)
+        else:
+            _, property_box = self.__material_def.GetProperty(material_property_id)
+            if isinstance(property_box, float):
+                return property_box
             else:
-                # To unset DS model if already assigned to the material in database
-                if self._edb_material_def.GetDielectricMaterialModel():
-                    self._edb_material_def.SetDielectricMaterialModel(self._edb_value(None))
+                return property_box.ToDouble()
+
+    # def __reset_property(self, name):
+    #     """Reset a property using the default value of the EDB API.
+    #
+    #     This method consists in resetting the value of a property by updating the inner property
+    #     to ``None`` and accessing the property afterward. When one wants to access a property
+    #     whose stored inner value is ``None``, the value is updated to the EDB API default value
+    #     associated to that property.
+    #     """
+    #     # Update inner property to None
+    #     setattr(self.__properties, name, None)
+    #     # Trigger get value on the property
+    #     _ = getattr(self, name)
 
 
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""
 
-    def __getitem__(self, item):
-        return self.materials[item]
+    def __init__(self, edb: Edb):
+        self.__edb = edb
+        self.__edb_definition = edb.edb_api.definition
+        self.__syslib = os.path.join(self.__edb.base_path, "syslib")
+        self.__materials: dict[str, Material] = {
+            material_def.GetName(): Material(self.__edb, material_def)
+            for material_def in list(self.__edb.active_db.MaterialDefs)
+        }
+
+    def __contains__(self, item):
+        if isinstance(item, Material):
+            return item.name in self.__materials
+        else:
+            return item in self.__materials
 
-    def __init__(self, pedb):
-        self._pedb = pedb
-        self._syslib = os.path.join(self._pedb.base_path, "syslib")
-        if not self.materials:
-            self.add_material("air")
-            self.add_material("copper", 1, 0.999991, 5.8e7, 0, 0)
-            self.add_material("fr4_epoxy", 4.4, 1, 0, 0.02, 0)
-            self.add_material("solder_mask", 3.1, 1, 0, 0.035, 0)
+    def __getitem__(self, item):
+        return self.__materials[item]
 
     @property
     def syslib(self):
-        """Retrieve the project sys library."""
-        return self._syslib
-
-    @pyedb_function_handler()
-    def _edb_value(self, value):
-        return self._pedb.edb_value(value)
+        """Get the project sys library."""
+        return self.__syslib
 
     @property
-    def _edb(self):
-        return self._pedb.edb_api
+    def materials(self):
+        """Get materials."""
+        return self.__materials
 
-    @property
-    def _db(self):
-        return self._pedb.active_db
+    def __edb_value(self, value):
+        """Convert a value to an EDB value.
 
-    @property
-    def materials(self):
-        """Retrieve dictionary of material from material library."""
-        return {obj.GetName(): Material(self, obj) for obj in list(self._db.MaterialDefs)}
+        Parameters
+        ----------
+        val : str, float, int
+        """
+        return self.__edb.edb_value(value)
 
     @pyedb_function_handler()
-    def add_material(
-        self,
-        name="air",
-        permittivity=1.0006,
-        permeability=1.0000004,
-        conductivity=0,
-        dielectric_loss_tangent=0,
-        magnetic_loss_tangent=0,
-    ):
+    def add_material(self, name: str, **kwargs):
         """Add a new material.
 
         Parameters
         ----------
-        name : str, optional
-            Material Name. The default is ``"air"``.
-        permittivity : float, str, optional
-            Material permittivity. The default is ``1.0006``.
-        permeability : float, str, optional
-            Material permeability. The default is ``1.0000004``.
-        conductivity : float, str, optional
-            Material conductivity. The default is ``0``.
-        dielectric_loss_tangent : float, str, optional
-            Material dielectric loss tangent. The default is ``0``.
-        magnetic_loss_tangent : float, str, optional
-            Material magnetic loss tangent. The default is ``0``.
+        name : str
+            Material name.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.materials.Material`
         """
-        if not name in self.materials:
-            self._edb.definition.MaterialDef.Create(self._db, name)
-            new_material = self.materials[name]
-            new_material.permittivity = permittivity
-            new_material.permeability = permeability
-            new_material.conductivity = conductivity
-            new_material.loss_tangent = dielectric_loss_tangent
-            new_material.magnetic_loss_tangent = magnetic_loss_tangent
-            return new_material
-        else:  # pragma: no cover
-            warnings.warn("Material {} already exists in material library.".format(name))
-            return False
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
+
+        material_def = self.__edb_definition.MaterialDef.Create(self.__edb.active_db, name)
+        material = Material(self.__edb, material_def)
+        attributes_input_dict = {key: val for (key, val) in kwargs.items() if key in ATTRIBUTES + DC_ATTRIBUTES}
+        if "loss_tangent" in kwargs:
+            warnings.warn(
+                "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                "Use key dielectric_loss_tangent instead.",
+                DeprecationWarning,
+            )
+            attributes_input_dict["dielectric_loss_tangent"] = kwargs["loss_tangent"]
+        if attributes_input_dict:
+            material.update(attributes_input_dict)
+
+        self.__materials[name] = material
+        return material
 
     @pyedb_function_handler()
-    def add_conductor_material(self, name, conductivity):
-        """Add a new conductor material in library.
+    def add_conductor_material(self, name, conductivity, **kwargs):
+        """Add a new conductor material.
 
         Parameters
         ----------
         name : str
             Name of the new material.
-        conductivity : float
+        conductivity : str, float, int
             Conductivity of the new material.
 
         Returns
@@ -477,99 +550,99 @@ class Materials(object):
         :class:`pyedb.dotnet.edb_core.materials.Material`
 
         """
-        if not name in self.materials:
-            self._edb.definition.MaterialDef.Create(self._db, name)
-            new_material = self.materials[name]
-            new_material.conductivity = conductivity
-            new_material.permittivity = 1
-            new_material.permeability = 1
-            return new_material
-        else:  # pragma: no cover
-            warnings.warn("Material {} already exists in material library.".format(name))
-            return False
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
+
+        extended_kwargs = {key: value for (key, value) in kwargs.items()}
+        extended_kwargs["conductivity"] = conductivity
+        material = self.add_material(name, **extended_kwargs)
+
+        self.__materials[name] = material
+        return material
 
     @pyedb_function_handler()
-    def add_dielectric_material(self, name, permittivity, loss_tangent, permeability=1):
+    def add_dielectric_material(self, name, permittivity, dielectric_loss_tangent, **kwargs):
         """Add a new dielectric material in library.
 
         Parameters
         ----------
         name : str
             Name of the new material.
-        permittivity : float
+        permittivity : str, float, int
             Permittivity of the new material.
-        loss_tangent : float
-            Loss tangent of the new material.
-        permeability : float
-            Permeability of the new material.
+        dielectric_loss_tangent : str, float, int
+            Dielectric loss tangent of the new material.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.materials.Material`
         """
-        if not name in self.materials:
-            self._edb.definition.MaterialDef.Create(self._db, name)
-            new_material = self.materials[name]
-            new_material.permittivity = permittivity
-            new_material.loss_tangent = loss_tangent
-            new_material.permeability = permeability
-            return new_material
-        else:
-            warnings.warn("Material {} already exists in material library.".format(name))
-            return False
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
 
-    @pyedb_function_handler()
-    def get_djordjevicsarkar_model(self, material_name=None):
-        """Djordjevic-Sarkar model if present.
+        extended_kwargs = {key: value for (key, value) in kwargs.items()}
+        extended_kwargs["permittivity"] = permittivity
+        extended_kwargs["dielectric_loss_tangent"] = dielectric_loss_tangent
+        material = self.add_material(name, **extended_kwargs)
 
-        Parameters
-        ----------
-        material_name : str
-
-        Returns
-        -------
-
-        """
-        material = self.materials[material_name]
-        if material:
-            return material.GetDielectricMaterialModel()
+        self.__materials[name] = material
+        return material
 
     @pyedb_function_handler()
-    def add_djordjevicsarkar_material(
-        self, name, permittivity, loss_tangent, test_frequency, dc_permittivity=None, dc_conductivity=None
+    def add_djordjevicsarkar_dielectric(
+        self,
+        name,
+        permittivity_at_frequency,
+        loss_tangent_at_frequency,
+        dielectric_model_frequency,
+        dc_conductivity=None,
+        dc_permittivity=None,
+        **kwargs,
     ):
-        """Create a Djordjevic_Sarkar dielectric.
+        """Add a dielectric using the Djordjevic-Sarkar model.
 
         Parameters
         ----------
         name : str
             Name of the dielectric.
-        permittivity : float
+        permittivity_at_frequency : str, float, int
             Relative permittivity of the dielectric.
-        loss_tangent : float
+        loss_tangent_at_frequency : str, float, int
             Loss tangent for the material.
-        test_frequency : float
+        dielectric_model_frequency : str, float, int
             Test frequency in GHz for the dielectric.
-        dc_permittivity : float, optional
-            DC Relative permittivity of the dielectric.
-        dc_conductivity : float, optional
-            DC Conductivity of the dielectric.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.materials.Material`
-            Material definition.
         """
-        material_def = self._edb.definition.DjordjecvicSarkarModel()
-        material_def.SetFrequency(test_frequency)
-        material_def.SetLossTangentAtFrequency(self._edb_value(loss_tangent))
-        material_def.SetRelativePermitivityAtFrequency(permittivity)
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
+
+        material_model = self.__edb_definition.DjordjecvicSarkarModel()
+        material_model.SetRelativePermitivityAtFrequency(permittivity_at_frequency)
+        material_model.SetLossTangentAtFrequency(self.__edb_value(loss_tangent_at_frequency))
+        material_model.SetFrequency(dielectric_model_frequency)
         if dc_conductivity is not None:
-            material_def.SetDCConductivity(dc_conductivity)
+            material_model.SetDCConductivity(dc_conductivity)
         if dc_permittivity is not None:
-            material_def.SetUseDCRelativePermitivity(True)
-            material_def.SetDCRelativePermitivity(dc_permittivity)
-        return self._add_dielectric_material_model(name, material_def)
+            material_model.SetUseDCRelativePermitivity(True)
+            material_model.SetDCRelativePermitivity(dc_permittivity)
+        try:
+            material = self.__add_dielectric_material_model(name, material_model)
+            for key, value in kwargs.items():
+                setattr(material, key, value)
+            if "loss_tangent" in kwargs:
+                warnings.warn(
+                    "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                    "Use key dielectric_loss_tangent instead.",
+                    DeprecationWarning,
+                )
+                setattr(material, "dielectric_loss_tangent", kwargs["loss_tangent"])
+            self.__materials[name] = material
+            return material
+        except MaterialModelException:
+            raise ValueError("Use realistic values to define DS model.")
 
     @pyedb_function_handler()
     def add_debye_material(
@@ -581,42 +654,61 @@ class Materials(object):
         loss_tangent_high,
         lower_freqency,
         higher_frequency,
+        **kwargs,
     ):
-        """Create a dielectric with the Debye model.
+        """Add a dielectric with the Debye model.
 
         Parameters
         ----------
         name : str
             Name of the dielectric.
-        permittivity_low : float
+        permittivity_low : float, int
             Relative permittivity of the dielectric at the frequency specified
             for ``lower_frequency``.
-        permittivity_high : float
+        permittivity_high : float, int
             Relative permittivity of the dielectric at the frequency specified
             for ``higher_frequency``.
-        loss_tangent_low : float
+        loss_tangent_low : float, int
             Loss tangent for the material at the frequency specified
             for ``lower_frequency``.
-        loss_tangent_high : float
+        loss_tangent_high : float, int
             Loss tangent for the material at the frequency specified
             for ``higher_frequency``.
-        lower_freqency : float
+        lower_freqency : str, float, int
             Value for the lower frequency.
-        higher_frequency : float
+        higher_frequency : str, float, int
             Value for the higher frequency.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.materials.Material`
-            Material definition.
         """
-        material_def = self._edb.definition.DebyeModel()
-        material_def.SetFrequencyRange(lower_freqency, higher_frequency)
-        material_def.SetLossTangentAtHighLowFrequency(loss_tangent_low, loss_tangent_high)
-        material_def.SetRelativePermitivityAtHighLowFrequency(
-            self._edb_value(permittivity_low), self._edb_value(permittivity_high)
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
+
+        material_model = self.__edb_definition.DebyeModel()
+        # FIXME: Seems like there is a bug here (we need to provide higher value for
+        # lower_freqency than higher_frequency)
+        material_model.SetFrequencyRange(lower_freqency, higher_frequency)
+        material_model.SetLossTangentAtHighLowFrequency(loss_tangent_low, loss_tangent_high)
+        material_model.SetRelativePermitivityAtHighLowFrequency(
+            self.__edb_value(permittivity_low), self.__edb_value(permittivity_high)
         )
-        return self._add_dielectric_material_model(name, material_def)
+        try:
+            material = self.__add_dielectric_material_model(name, material_model)
+            for key, value in kwargs.items():
+                setattr(material, key, value)
+            if "loss_tangent" in kwargs:
+                warnings.warn(
+                    "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                    "Use key dielectric_loss_tangent instead.",
+                    DeprecationWarning,
+                )
+                setattr(material, "dielectric_loss_tangent", kwargs["loss_tangent"])
+            self.__materials[name] = material
+            return material
+        except MaterialModelException:
+            raise ValueError("Use realistic values to define Debye model.")
 
     @pyedb_function_handler()
     def add_multipole_debye_material(
@@ -625,8 +717,9 @@ class Materials(object):
         frequencies,
         permittivities,
         loss_tangents,
+        **kwargs,
     ):
-        """Create a dielectric with the Multipole Debye model.
+        """Add a dielectric with the Multipole Debye model.
 
         Parameters
         ----------
@@ -642,7 +735,6 @@ class Materials(object):
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.materials.Material`
-            Material definition.
 
         Examples
         --------
@@ -653,32 +745,58 @@ class Materials(object):
         >>> loss_tan = [0.025, 0.026, 0.027, 0.028, 0.029, 0.030]
         >>> diel = edb.materials.add_multipole_debye_material("My_MP_Debye", freq, rel_perm, loss_tan)
         """
+        if name in self.__materials:
+            raise ValueError(f"Material {name} already exists in material library.")
+
         frequencies = [float(i) for i in frequencies]
         permittivities = [float(i) for i in permittivities]
         loss_tangents = [float(i) for i in loss_tangents]
-        material_def = self._edb.definition.MultipoleDebyeModel()
-        material_def.SetParameters(
+        material_model = self.__edb_definition.MultipoleDebyeModel()
+        material_model.SetParameters(
             convert_py_list_to_net_list(frequencies),
             convert_py_list_to_net_list(permittivities),
             convert_py_list_to_net_list(loss_tangents),
         )
-        return self._add_dielectric_material_model(name, material_def)
+        try:
+            material = self.__add_dielectric_material_model(name, material_model)
+            for key, value in kwargs.items():
+                setattr(material, key, value)
+            if "loss_tangent" in kwargs:
+                warnings.warn(
+                    "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                    "Use key dielectric_loss_tangent instead.",
+                    DeprecationWarning,
+                )
+                setattr(material, "dielectric_loss_tangent", kwargs["loss_tangent"])
+            self.__materials[name] = material
+            return material
+        except MaterialModelException:
+            raise ValueError("Use realistic values to define Multipole Debye model.")
 
     @pyedb_function_handler()
-    def _add_dielectric_material_model(self, name, material_model):
-        if self._edb.definition.MaterialDef.FindByName(self._db, name).IsNull():
-            self._edb.definition.MaterialDef.Create(self._db, name)
-        material_def = self._edb.definition.MaterialDef.FindByName(self._db, name)
+    def __add_dielectric_material_model(self, name, material_model):
+        """Add a dielectric material model.
+
+        Parameters
+        ----------
+        name : str
+            Name of the dielectric.
+        material_model : Any
+            Dielectric material model.
+        """
+        if self.__edb_definition.MaterialDef.FindByName(self.__edb.active_db, name).IsNull():
+            self.__edb_definition.MaterialDef.Create(self.__edb.active_db, name)
+        material_def = self.__edb_definition.MaterialDef.FindByName(self.__edb.active_db, name)
         succeeded = material_def.SetDielectricMaterialModel(material_model)
         if succeeded:
-            return material_def
-        return False
+            material = Material(self.__edb, material_def)
+            return material
+        raise MaterialModelException("Set dielectric material model failed.")
 
     @pyedb_function_handler()
     def duplicate(self, material_name, new_material_name):
         """Duplicate a material from the database.
 
-
         Parameters
         ----------
         material_name : str
@@ -688,53 +806,52 @@ class Materials(object):
 
         Returns
         -------
-        EDB material : class: 'Ansys.Ansoft.Edb.definition.MaterialDef'
+        :class:`pyedb.dotnet.edb_core.materials.Material`
+        """
+        if new_material_name in self.__materials:
+            raise ValueError(f"Material {new_material_name} already exists in material library.")
 
+        material = self.materials[material_name]
+        material_def = self.__edb_definition.MaterialDef.Create(self.__edb.active_db, new_material_name)
+        material_dict = material.to_dict()
+        new_material = Material(self.__edb, material_def)
+        new_material.update(material_dict)
 
-        Examples
-        --------
+        self.__materials[new_material_name] = new_material
+        return new_material
 
-        >>> from pyedb import Edb
-        >>> edb_app = Edb()
-        >>> my_material = edb_app.materials.duplicate("copper", "my_new_copper")
+    @pyedb_function_handler()
+    def delete_material(self, material_name):
+        """Remove a material from the database."""
+        material_def = self.__edb_definition.MaterialDef.FindByName(self.__edb.active_db, material_name)
+        if material_def.IsNull():
+            raise ValueError(f"Cannot find material {material_name}.")
+        material_def.Delete()
+        del self.__materials[material_name]
 
-        """
-        material_list = {i.lower(): i for i in list(self.materials.keys())}
-        if material_name.lower() in material_list and new_material_name not in self.materials:
-            material_name = material_list[material_name.lower()]
-            permittivity = self._edb_value(self.materials[material_name].permittivity)
-            permeability = self._edb_value(self.materials[material_name].permeability)
-            conductivity = self._edb_value(self.materials[material_name].conductivity)
-            dielectric_loss_tangent = self._edb_value(self.materials[material_name].loss_tangent)
-            magnetic_loss_tangent = self._edb_value(self.materials[material_name].magnetic_loss_tangent)
-            thermal_conductivity = self._edb_value(self.materials[material_name].thermal_conductivity)
-            thermal_expansion_coefficient = self._edb_value(self.materials[material_name].thermal_expansion_coefficient)
-            youngs_modulus = self._edb_value(self.materials[material_name].youngs_modulus)
-            poisson_ratio = self._edb_value(self.materials[material_name].poisson_ratio)
-            mass_density = self._edb_value(self.materials[material_name].mass_density)
-            material_model = self.materials[material_name]._edb_material_def.GetDielectricMaterialModel()
-            edb_material = self._edb.definition.MaterialDef.Create(self._db, new_material_name)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.Permittivity, permittivity)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.Permeability, permeability)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.Conductivity, conductivity)
-            edb_material.SetProperty(
-                self._edb.definition.MaterialPropertyId.DielectricLossTangent, dielectric_loss_tangent
-            )
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.ThermalConductivity, thermal_conductivity)
-            edb_material.SetProperty(
-                self._edb.definition.MaterialPropertyId.ThermalExpansionCoefficient, thermal_expansion_coefficient
+    @pyedb_function_handler()
+    def update_material(self, material_name, input_dict):
+        """Update material attributes."""
+        if material_name not in self.__materials:
+            raise ValueError(f"Material {material_name} does not exist in material library.")
+
+        material = self[material_name]
+        attributes_input_dict = {key: val for (key, val) in input_dict.items() if key in ATTRIBUTES + DC_ATTRIBUTES}
+        if "loss_tangent" in input_dict:
+            warnings.warn(
+                "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                "Use key dielectric_loss_tangent instead.",
+                DeprecationWarning,
             )
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.MassDensity, mass_density)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.YoungsModulus, youngs_modulus)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.PoissonsRatio, poisson_ratio)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.MagneticLossTangent, magnetic_loss_tangent)
-            edb_material.SetProperty(self._edb.definition.MaterialPropertyId.MagneticLossTangent, magnetic_loss_tangent)
-            edb_material.SetDielectricMaterialModel(material_model)
-
-            return edb_material
+            attributes_input_dict["dielectric_loss_tangent"] = input_dict["loss_tangent"]
+        if attributes_input_dict:
+            material.update(attributes_input_dict)
+        self.__materials[material_name] = material
+        return material
 
     @pyedb_function_handler()
-    def _load_materials(self, material=None):
+    def load_material(self, material):
+        """Load material."""
         if self.materials:
             mat_keys = [i.lower() for i in self.materials.keys()]
             mat_keys_case = [i for i in self.materials.keys()]
@@ -755,8 +872,26 @@ class Materials(object):
         else:
             self.materials[mat_keys_case[mat_keys.index(material["name"].lower())]]._load(material)
 
+        if material:
+            material_name = material["name"]
+            material_conductivity = material.get("conductivity", None)
+            if material_conductivity and material_conductivity > 1e4:
+                self.add_conductor_material(material_name, material_conductivity)
+            else:
+                material_permittivity = material["permittivity"]
+                if "loss_tangent" in material:
+                    warnings.warn(
+                        "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                        "Use key dielectric_loss_tangent instead.",
+                        DeprecationWarning,
+                    )
+                    material_dlt = material["loss_tangent"]
+                else:
+                    material_dlt = material["dielectric_loss_tangent"]
+                self.add_dielectric_material(material_name, material_permittivity, material_dlt)
+
     @pyedb_function_handler()
-    def material_name_to_id(self, property_name):
+    def material_property_to_id(self, property_name):
         """Convert a material property name to a material property ID.
 
         Parameters
@@ -766,78 +901,36 @@ class Materials(object):
 
         Returns
         -------
-        ID of the material property.
+        Any
         """
-        props = {
-            "Permittivity": self._edb.definition.MaterialPropertyId.Permittivity,
-            "Permeability": self._edb.definition.MaterialPropertyId.Permeability,
-            "Conductivity": self._edb.definition.MaterialPropertyId.Conductivity,
-            "DielectricLossTangent": self._edb.definition.MaterialPropertyId.DielectricLossTangent,
-            "MagneticLossTangent": self._edb.definition.MaterialPropertyId.MagneticLossTangent,
-            "ThermalConductivity": self._edb.definition.MaterialPropertyId.ThermalConductivity,
-            "MassDensity": self._edb.definition.MaterialPropertyId.MassDensity,
-            "SpecificHeat": self._edb.definition.MaterialPropertyId.SpecificHeat,
-            "YoungsModulus": self._edb.definition.MaterialPropertyId.YoungsModulus,
-            "PoissonsRatio": self._edb.definition.MaterialPropertyId.PoissonsRatio,
-            "ThermalExpansionCoefficient": self._edb.definition.MaterialPropertyId.ThermalExpansionCoefficient,
-            "InvalidProperty": self._edb.definition.MaterialPropertyId.InvalidProperty,
+        material_property_id = self.__edb_definition.MaterialPropertyId
+        property_name_to_id = {
+            "Permittivity": material_property_id.Permittivity,
+            "Permeability": material_property_id.Permeability,
+            "Conductivity": material_property_id.Conductivity,
+            "DielectricLossTangent": material_property_id.DielectricLossTangent,
+            "MagneticLossTangent": material_property_id.MagneticLossTangent,
+            "ThermalConductivity": material_property_id.ThermalConductivity,
+            "MassDensity": material_property_id.MassDensity,
+            "SpecificHeat": material_property_id.SpecificHeat,
+            "YoungsModulus": material_property_id.YoungsModulus,
+            "PoissonsRatio": material_property_id.PoissonsRatio,
+            "ThermalExpansionCoefficient": material_property_id.ThermalExpansionCoefficient,
+            "InvalidProperty": material_property_id.InvalidProperty,
         }
 
-        found_el = difflib.get_close_matches(property_name, list(props.keys()), 1, 0.7)
-        if found_el:
-            return props[found_el[0]]
-        else:
-            return self._edb.definition.MaterialPropertyId.InvalidProperty
-
-    @pyedb_function_handler()
-    def get_property_by_material_name(self, property_name, material_name):
-        """Get the property of a material. If it is executed in IronPython,
-         you must only use the first element of the returned tuple, which is a float.
-
-        Parameters
-        ----------
-        material_name : str
-            Name of the existing material.
-        property_name : str
-            Name of the material property.
-            ``permittivity``
-            ``permeability``
-            ``conductivity``
-            ``dielectric_loss_tangent``
-            ``magnetic_loss_tangent``
-
-        Returns
-        -------
-        float
-            The float value of the property.
-
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edb_app = Edb()
-        >>> returned_tuple = edb_app.materials.get_property_by_material_name("conductivity", "copper")
-        >>> edb_value = returned_tuple[0]
-        >>> float_value = returned_tuple[1]
-
-        """
-        if self._edb.definition.MaterialDef.FindByName(self._pedb._db, material_name).IsNull():
-            self._pedb.logger.error("This material doesn't exists.")
+        if property_name == "loss_tangent":
+            warnings.warn(
+                "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                "Use key dielectric_loss_tangent instead.",
+                DeprecationWarning,
+            )
+            property_name = "dielectric_loss_tangent"
+        match = difflib.get_close_matches(property_name, property_name_to_id, 1, 0.7)
+        if match:
+            return property_name_to_id[match[0]]
         else:
-            original_material = self._edb.definition.MaterialDef.FindByName(self._pedb._db, material_name)
-            if is_ironpython:  # pragma: no cover
-                property_box = _clr.StrongBox[float]()
-                original_material.GetProperty(self.material_name_to_id(property_name), property_box)
-                return float(property_box)
-            else:
-                _, property_box = original_material.GetProperty(
-                    self.material_name_to_id(property_name), self._edb_value(0.0)
-                )
-                if isinstance(property_box, float):
-                    return property_box
-                else:
-                    return property_box.ToDouble()
-        return False
+            return property_name_to_id["InvalidProperty"]
 
     @pyedb_function_handler()
     def load_amat(self, amat_file):
@@ -853,24 +946,24 @@ class Materials(object):
         bool
         """
         if not os.path.exists(amat_file):
-            self._pedb.logger.error("File path {} does not exist.".format(amat_file))
-        material_dict = self.read_materials(amat_file)
-        for material_name, material in material_dict.items():
-            if not material_name in list(self.materials.keys()):
-                new_material = self.add_material(name=material_name)
-                properties = [
-                    "permittivity",
-                    "conductivity",
-                    "mass_density",
-                    "permeability",
-                    "specific_heat",
-                    "thermal_expansion_coefficient",
-                ]
-                for mat_prop_name, mat_prop_value in material.items():
-                    if mat_prop_name in properties:
-                        setattr(new_material, mat_prop_name, mat_prop_value)
-                    if mat_prop_name == "tangent_delta":
-                        new_material.loss_tangent = mat_prop_value
+            raise FileNotFoundError(f"File path {amat_file} does not exist.")
+        materials_dict = self.read_materials(amat_file)
+        for material_name, material_properties in materials_dict.items():
+            if not material_name in self:
+                if "tangent_delta" in material_properties:
+                    material_properties["dielectric_loss_tangent"] = material_properties["tangent_delta"]
+                    del material_properties["tangent_delta"]
+                elif "loss_tangent" in material_properties:
+                    warnings.warn(
+                        "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                        "Use key dielectric_loss_tangent instead.",
+                        DeprecationWarning,
+                    )
+                    material_properties["dielectric_loss_tangent"] = material_properties["loss_tangent"]
+                    del material_properties["loss_tangent"]
+                self.add_material(material_name, **material_properties)
+            else:
+                self.__edb.logger.warning(f"Material {material_name} already exist and was not loaded from AMAT file.")
         return True
 
     @staticmethod
@@ -886,11 +979,12 @@ class Materials(object):
         Returns
         -------
         dict
-            {material name: dict of material property to value}.
+            {material name: dict of material properties}.
         """
 
         def get_line_float_value(line):
             """Retrieve the float value expected in the line of an AMAT file.
+
             The associated string is expected to follow one of the following cases:
             - simple('permittivity', 12.)
             - permittivity='12'.
@@ -903,7 +997,7 @@ class Materials(object):
         res = {}
         _begin_search = re.compile(r"^\$begin '(.+)'")
         _end_search = re.compile(r"^\$end '(.+)'")
-        amat_keys = [
+        material_properties = [
             "thermal_conductivity",
             "permittivity",
             "dielectric_loss_tangent",
@@ -913,48 +1007,50 @@ class Materials(object):
             "specific_heat",
             "mass_density",
         ]
-        keys = [
-            "thermal_conductivity",
-            "permittivity",
-            "tangent_delta",
-            "permeability",
-            "magnetic_loss_tangent",
-            "thermal_expansion_coeffcient",
-            "specific_heat",
-            "mass_density",
-        ]
 
         with open(amat_file, "r") as amat_fh:
             raw_lines = amat_fh.read().splitlines()
-            mat_found = ""
+            material_name = ""
             for line in raw_lines:
                 b = _begin_search.search(line)
                 if b:  # walk down a level
-                    mat_found = b.group(1)
-                    res.setdefault(mat_found, {})
-                if mat_found:
-                    for amat_key, key in zip(amat_keys, keys):
-                        if amat_key in line:
+                    material_name = b.group(1)
+                    res.setdefault(material_name, {})
+                    if len(res) > 165:
+                        pass
+                if material_name:
+                    for material_property in material_properties:
+                        if material_property in line:
                             value = get_line_float_value(line)
                             if value is not None:
-                                res[mat_found][key] = value
+                                res[material_name][material_property] = value
+                            break
                     # Extra case to avoid confusion ("conductivity" is included in "thermal_conductivity")
                     if "conductivity" in line and "thermal_conductivity" not in line:
                         value = get_line_float_value(line)
                         if value is not None:
-                            res[mat_found]["conductivity"] = value
+                            res[material_name]["conductivity"] = value
+                    # Extra case to avoid confusion ("conductivity" is included in "thermal_conductivity")
+                    if (
+                        "loss_tangent" in line
+                        and "dielectric_loss_tangent" not in line
+                        and "magnetic_loss_tangent" not in line
+                    ):
+                        warnings.warn(
+                            "This key is deprecated in versions >0.7.0 and will soon be removed. "
+                            "Use key dielectric_loss_tangent instead.",
+                            DeprecationWarning,
+                        )
+                        value = get_line_float_value(line)
+                        if value is not None:
+                            res[material_name]["dielectric_loss_tangent"] = value
                 end = _end_search.search(line)
                 if end:
-                    mat_found = ""
+                    material_name = ""
 
         # Clean unwanted data
-        try:
-            del res["$index$"]
-        except KeyError:
-            pass
-        try:
-            del res["$base_index$"]
-        except KeyError:
-            pass
+        for key in ("$index$", "$base_index$"):
+            if key in res:
+                del res[key]
 
         return res