# Copyright (C) 2021 - 2024 ANSYS, Inc. and/or its affiliates.
# SPDX-License-Identifier: MIT
#
#
# 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.

"""Module providing the Mat221 class."""
import typing
from ansys.dyna.core.lib.card import Card, Field, Flag
from ansys.dyna.core.lib.field_schema import FieldSchema
from ansys.dyna.core.lib.option_card import OptionCardSet, OptionSpec
from ansys.dyna.core.lib.keyword_base import KeywordBase

_MAT221_CARD0 = (
    FieldSchema("mid", int, 0, 10, None),
    FieldSchema("ro", float, 10, 10, None),
    FieldSchema("ea", float, 20, 10, None),
    FieldSchema("eb", float, 30, 10, None),
    FieldSchema("ec", float, 40, 10, None),
    FieldSchema("prba", float, 50, 10, None),
    FieldSchema("prca", float, 60, 10, None),
    FieldSchema("prcb", float, 70, 10, None),
)

_MAT221_CARD1 = (
    FieldSchema("gab", float, 0, 10, None),
    FieldSchema("gbc", float, 10, 10, None),
    FieldSchema("gca", float, 20, 10, None),
    FieldSchema("unused", int, 30, 10, None),
    FieldSchema("aopt", float, 40, 10, None),
    FieldSchema("macf", int, 50, 10, 1),
)

_MAT221_CARD2 = (
    FieldSchema("xp", float, 0, 10, None),
    FieldSchema("yp", float, 10, 10, None),
    FieldSchema("zp", float, 20, 10, None),
    FieldSchema("a1", float, 30, 10, None),
    FieldSchema("a2", float, 40, 10, None),
    FieldSchema("a3", float, 50, 10, None),
)

_MAT221_CARD3 = (
    FieldSchema("v1", float, 0, 10, None),
    FieldSchema("v2", float, 10, 10, None),
    FieldSchema("v3", float, 20, 10, None),
    FieldSchema("d1", float, 30, 10, None),
    FieldSchema("d2", float, 40, 10, None),
    FieldSchema("d3", float, 50, 10, None),
    FieldSchema("beta", float, 60, 10, None),
)

_MAT221_CARD4 = (
    FieldSchema("nerode", int, 0, 10, 0),
    FieldSchema("ndam", int, 10, 10, 0),
    FieldSchema("eps1tf", float, 20, 10, 1e+20),
    FieldSchema("eps2tf", float, 30, 10, 1e+20),
    FieldSchema("eps3tf", float, 40, 10, 1e+20),
    FieldSchema("eps1cf", float, 50, 10, -1e+20),
    FieldSchema("eps2cf", float, 60, 10, -1e+20),
    FieldSchema("eps3cf", float, 70, 10, -1e+20),
)

_MAT221_CARD5 = (
    FieldSchema("eps12f", float, 0, 10, 1e+20),
    FieldSchema("eps23f", float, 10, 10, 1e+20),
    FieldSchema("eps13f", float, 20, 10, 1e+20),
    FieldSchema("epsd1t", float, 30, 10, None),
    FieldSchema("epsc1t", float, 40, 10, None),
    FieldSchema("cdam1t", float, 50, 10, None),
    FieldSchema("epsd2t", float, 60, 10, None),
    FieldSchema("epsc2t", float, 70, 10, None),
)

_MAT221_CARD6 = (
    FieldSchema("cdam2t", float, 0, 10, 0.0),
    FieldSchema("epsd3t", float, 10, 10, 0.0),
    FieldSchema("epsc3t", float, 20, 10, None),
    FieldSchema("cdam3t", float, 30, 10, None),
    FieldSchema("epsd1c", float, 40, 10, None),
    FieldSchema("epsc1c", float, 50, 10, None),
    FieldSchema("cdam1c", float, 60, 10, None),
    FieldSchema("epsd2c", float, 70, 10, None),
)

_MAT221_CARD7 = (
    FieldSchema("epsc2c", float, 0, 10, None),
    FieldSchema("cdam2c", float, 10, 10, None),
    FieldSchema("epsd3c", float, 20, 10, None),
    FieldSchema("epsc3c", float, 30, 10, None),
    FieldSchema("cdam3c", float, 40, 10, None),
    FieldSchema("epsd12", float, 50, 10, None),
    FieldSchema("epsc12", float, 60, 10, None),
    FieldSchema("cdam12", float, 70, 10, None),
)

_MAT221_CARD8 = (
    FieldSchema("epsd23", float, 0, 10, None),
    FieldSchema("epsc23", float, 10, 10, None),
    FieldSchema("cdam23", float, 20, 10, None),
    FieldSchema("epsd31", float, 30, 10, None),
    FieldSchema("epsc31", float, 40, 10, None),
    FieldSchema("cdam31", float, 50, 10, None),
)

_MAT221_OPTION0_CARD0 = (
    FieldSchema("title", str, 0, 80, None),
)

class Mat221(KeywordBase):
    """DYNA MAT_221 keyword"""

    keyword = "MAT"
    subkeyword = "221"
    option_specs = [
        OptionSpec("TITLE", -1, 1),
    ]

    def __init__(self, **kwargs):
        """Initialize the Mat221 class."""
        super().__init__(**kwargs)
        kwargs["parent"] = self
        self._cards = [
            Card.from_field_schemas_with_defaults(
                _MAT221_CARD0,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD1,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD2,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD3,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD4,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD5,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD6,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD7,
                **kwargs,
            ),            Card.from_field_schemas_with_defaults(
                _MAT221_CARD8,
                **kwargs,
            ),            OptionCardSet(
                option_spec = Mat221.option_specs[0],
                cards = [
                    Card.from_field_schemas_with_defaults(
                        _MAT221_OPTION0_CARD0,
                        **kwargs,
                    ),
                ],
                **kwargs
            ),
        ]
    @property
    def mid(self) -> typing.Optional[int]:
        """Get or set the Material identification. A unique number or label must be specified.
        """ # nopep8
        return self._cards[0].get_value("mid")

    @mid.setter
    def mid(self, value: int) -> None:
        """Set the mid property."""
        self._cards[0].set_value("mid", value)

    @property
    def ro(self) -> typing.Optional[float]:
        """Get or set the Mass density.
        """ # nopep8
        return self._cards[0].get_value("ro")

    @ro.setter
    def ro(self, value: float) -> None:
        """Set the ro property."""
        self._cards[0].set_value("ro", value)

    @property
    def ea(self) -> typing.Optional[float]:
        """Get or set the Ea, Young's modulus in a-direction.
        """ # nopep8
        return self._cards[0].get_value("ea")

    @ea.setter
    def ea(self, value: float) -> None:
        """Set the ea property."""
        self._cards[0].set_value("ea", value)

    @property
    def eb(self) -> typing.Optional[float]:
        """Get or set the Eb, Young's modulus in b-direction.
        """ # nopep8
        return self._cards[0].get_value("eb")

    @eb.setter
    def eb(self, value: float) -> None:
        """Set the eb property."""
        self._cards[0].set_value("eb", value)

    @property
    def ec(self) -> typing.Optional[float]:
        """Get or set the Eb, Young's modulus in c-direction.
        """ # nopep8
        return self._cards[0].get_value("ec")

    @ec.setter
    def ec(self, value: float) -> None:
        """Set the ec property."""
        self._cards[0].set_value("ec", value)

    @property
    def prba(self) -> typing.Optional[float]:
        """Get or set the Vba, Poisson's ratio, ba.
        """ # nopep8
        return self._cards[0].get_value("prba")

    @prba.setter
    def prba(self, value: float) -> None:
        """Set the prba property."""
        self._cards[0].set_value("prba", value)

    @property
    def prca(self) -> typing.Optional[float]:
        """Get or set the Vca, Poisson's ratio, ca.
        """ # nopep8
        return self._cards[0].get_value("prca")

    @prca.setter
    def prca(self, value: float) -> None:
        """Set the prca property."""
        self._cards[0].set_value("prca", value)

    @property
    def prcb(self) -> typing.Optional[float]:
        """Get or set the Vcb, Poisson's ratio, cb.
        """ # nopep8
        return self._cards[0].get_value("prcb")

    @prcb.setter
    def prcb(self, value: float) -> None:
        """Set the prcb property."""
        self._cards[0].set_value("prcb", value)

    @property
    def gab(self) -> typing.Optional[float]:
        """Get or set the Gab, Shear modulus, ab.
        """ # nopep8
        return self._cards[1].get_value("gab")

    @gab.setter
    def gab(self, value: float) -> None:
        """Set the gab property."""
        self._cards[1].set_value("gab", value)

    @property
    def gbc(self) -> typing.Optional[float]:
        """Get or set the Gbc, Shear modulus, bc.
        """ # nopep8
        return self._cards[1].get_value("gbc")

    @gbc.setter
    def gbc(self, value: float) -> None:
        """Set the gbc property."""
        self._cards[1].set_value("gbc", value)

    @property
    def gca(self) -> typing.Optional[float]:
        """Get or set the Gca, Shear modulus, ca.
        """ # nopep8
        return self._cards[1].get_value("gca")

    @gca.setter
    def gca(self, value: float) -> None:
        """Set the gca property."""
        self._cards[1].set_value("gca", value)

    @property
    def aopt(self) -> typing.Optional[float]:
        """Get or set the Material axes option (see MAT_OPTIONTROPIC_ELASTIC, particularly the Material Directions section, for details):
        EQ.0.0:	Locally orthotropic with material axes determined by element nodes 1, 2,and 4, as with* DEFINE_COORDINATE_NODES.
        EQ.1.0 : Locally orthotropic with material axes determined by a point, P, in spaceand the global location of the element center; this is the a - direction.This option is for solid elements only.
        EQ.2.0:	Globally orthotropic with material axes determined by vectors defined below, as with* DEFINE_COORDINATE_VECTOR
        EQ.3.0 : Locally orthotropic material axes determined by a vector v and the normal vector to the plane of the element.The plane of a solid element is the midsurface between the inner surface and outer surface defined by the first four nodes and the last four nodes of the connectivity of the element, respectively.Thus, for solid elements, AOPT = 3 is only available for hexahedrons.a is determined by taking the cross product of v with the normal vector, b is determined by taking the cross product of the normal vector with a,and c is the normal vector.Then aand b are rotated about c by an angle BETA.BETA may be set in the keyword input for the element or in the input for this keyword.Note that for solids, the material axes may be switched depending on the choice of MACF.The switch may occur before or after applying BETA depending on the value of MACF.
        EQ.4.0 : Locally orthotropic in a cylindrical coordinate system with the material axes determined by a vector v,and an originating point, P, which define the centerline axis.This option is for solid elements only.
        LT.0.0 : The absolute value of AOPT is a coordinate system ID number(CID on * DEFINE_COORDINATE_OPTION)
        """ # nopep8
        return self._cards[1].get_value("aopt")

    @aopt.setter
    def aopt(self, value: float) -> None:
        """Set the aopt property."""
        self._cards[1].set_value("aopt", value)

    @property
    def macf(self) -> int:
        """Get or set the Material axes change flag for solid elements:
        EQ. - 4:	Switch material axes b and c before BETA rotation
        EQ. - 3 : Switch material axes a and c before BETA rotation
        EQ. - 2 : Switch material axes a and b before BETA rotation
        EQ.1 : No change, default
        EQ.2 : Switch material axes a and b after BETA rotation
        EQ.3 : Switch material axes a and c after BETA rotation
        EQ.4 : Switch material axes b and c after BETA rotation
        Figure Error!Reference source not found.indicates when LS - DYNA applies MACF during the process to obtain the final material axes.If BETA on * ELEMENT_SOLID_{OPTION} is defined, then that BETA is used for the rotation for all AOPT options.Otherwise, if AOPT = 3, the BETA input on Card 4 rotates the axes.For all other values of AOPT, the material axes will be switched as specified by MACF, but no BETA rotation will be performed.
        """ # nopep8
        return self._cards[1].get_value("macf")

    @macf.setter
    def macf(self, value: int) -> None:
        """Set the macf property."""
        if value not in [1, 2, 3, 4, -2, -3, -4, None]:
            raise Exception("""macf must be `None` or one of {1,2,3,4,-2,-3,-4}.""")
        self._cards[1].set_value("macf", value)

    @property
    def xp(self) -> typing.Optional[float]:
        """Get or set the Coordinates of point p for AOPT = 1.
        """ # nopep8
        return self._cards[2].get_value("xp")

    @xp.setter
    def xp(self, value: float) -> None:
        """Set the xp property."""
        self._cards[2].set_value("xp", value)

    @property
    def yp(self) -> typing.Optional[float]:
        """Get or set the Coordinates of point p for AOPT = 1.
        """ # nopep8
        return self._cards[2].get_value("yp")

    @yp.setter
    def yp(self, value: float) -> None:
        """Set the yp property."""
        self._cards[2].set_value("yp", value)

    @property
    def zp(self) -> typing.Optional[float]:
        """Get or set the Coordinates of point p for AOPT = 1.
        """ # nopep8
        return self._cards[2].get_value("zp")

    @zp.setter
    def zp(self, value: float) -> None:
        """Set the zp property."""
        self._cards[2].set_value("zp", value)

    @property
    def a1(self) -> typing.Optional[float]:
        """Get or set the Components of vector a for AOPT = 2.
        """ # nopep8
        return self._cards[2].get_value("a1")

    @a1.setter
    def a1(self, value: float) -> None:
        """Set the a1 property."""
        self._cards[2].set_value("a1", value)

    @property
    def a2(self) -> typing.Optional[float]:
        """Get or set the Components of vector a for AOPT = 2.
        """ # nopep8
        return self._cards[2].get_value("a2")

    @a2.setter
    def a2(self, value: float) -> None:
        """Set the a2 property."""
        self._cards[2].set_value("a2", value)

    @property
    def a3(self) -> typing.Optional[float]:
        """Get or set the Components of vector a for AOPT = 2.
        """ # nopep8
        return self._cards[2].get_value("a3")

    @a3.setter
    def a3(self, value: float) -> None:
        """Set the a3 property."""
        self._cards[2].set_value("a3", value)

    @property
    def v1(self) -> typing.Optional[float]:
        """Get or set the Components of vector v for AOPT = 3.
        """ # nopep8
        return self._cards[3].get_value("v1")

    @v1.setter
    def v1(self, value: float) -> None:
        """Set the v1 property."""
        self._cards[3].set_value("v1", value)

    @property
    def v2(self) -> typing.Optional[float]:
        """Get or set the Components of vector v for AOPT = 3.
        """ # nopep8
        return self._cards[3].get_value("v2")

    @v2.setter
    def v2(self, value: float) -> None:
        """Set the v2 property."""
        self._cards[3].set_value("v2", value)

    @property
    def v3(self) -> typing.Optional[float]:
        """Get or set the Components of vector v for AOPT = 3.
        """ # nopep8
        return self._cards[3].get_value("v3")

    @v3.setter
    def v3(self, value: float) -> None:
        """Set the v3 property."""
        self._cards[3].set_value("v3", value)

    @property
    def d1(self) -> typing.Optional[float]:
        """Get or set the Components of vector d for AOPT = 2.
        """ # nopep8
        return self._cards[3].get_value("d1")

    @d1.setter
    def d1(self, value: float) -> None:
        """Set the d1 property."""
        self._cards[3].set_value("d1", value)

    @property
    def d2(self) -> typing.Optional[float]:
        """Get or set the Components of vector d for AOPT = 2.
        """ # nopep8
        return self._cards[3].get_value("d2")

    @d2.setter
    def d2(self, value: float) -> None:
        """Set the d2 property."""
        self._cards[3].set_value("d2", value)

    @property
    def d3(self) -> typing.Optional[float]:
        """Get or set the Components of vector d for AOPT = 2.
        """ # nopep8
        return self._cards[3].get_value("d3")

    @d3.setter
    def d3(self, value: float) -> None:
        """Set the d3 property."""
        self._cards[3].set_value("d3", value)

    @property
    def beta(self) -> typing.Optional[float]:
        """Get or set the Material angle in degrees for AOPT = 3, may be overridden on the element card, see *ELEMENT_SOLID_ORTHO.
        """ # nopep8
        return self._cards[3].get_value("beta")

    @beta.setter
    def beta(self, value: float) -> None:
        """Set the beta property."""
        self._cards[3].set_value("beta", value)

    @property
    def nerode(self) -> int:
        """Get or set the Failure and erosion flag:
        EQ. 0: No failure (default)
        EQ. 1: Failure as soon as one failure criterion is reached in all
        integration points
        EQ. 2: Failure as soon as one failure criterion is reached in at least
        one integration point
        EQ. 3: Failure as soon as a tension or compression failure criterion
        in the a-direction is reached for one integration point
        EQ. 4: Failure as soon as a tension or compression failure criterion
        in the b-direction is reached for one integration point
        EQ. 5: Failure as soon as a tension or compression failure criterion
        in the c-direction is reached for one integration point
        EQ. 6: Failure as soon as tension or compression failure criteria in
        both the a- and b-directions are reached at a single integration
        point or at 2 different integration points
        EQ. 7: Failure as soon as tension or compression failure criteria in
        both the b- and c-directions are reached at a single integration
        point or at 2 different integration points
        EQ. 8: Failure as soon as tension or compression failure criteria in
        both the a- and c-directions are reached at a single integration
        point or at 2 different integration points
        EQ. 9: Failure as soon as tension or compression failure criteria in
        the 3 directions are reached at a single integration point or at
        different integration points.
        """ # nopep8
        return self._cards[4].get_value("nerode")

    @nerode.setter
    def nerode(self, value: int) -> None:
        """Set the nerode property."""
        if value not in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, None]:
            raise Exception("""nerode must be `None` or one of {0,1,2,3,4,5,6,7,8,9}.""")
        self._cards[4].set_value("nerode", value)

    @property
    def ndam(self) -> int:
        """Get or set the Damage flag:
        EQ. 0: No damage (default)
        EQ. 1: Damage in tension only (null for compression)
        EQ. 2: Damage in tension and compression.
        """ # nopep8
        return self._cards[4].get_value("ndam")

    @ndam.setter
    def ndam(self, value: int) -> None:
        """Set the ndam property."""
        if value not in [0, 1, 2, None]:
            raise Exception("""ndam must be `None` or one of {0,1,2}.""")
        self._cards[4].set_value("ndam", value)

    @property
    def eps1tf(self) -> float:
        """Get or set the Failure strain in tension along the a-direction.
        """ # nopep8
        return self._cards[4].get_value("eps1tf")

    @eps1tf.setter
    def eps1tf(self, value: float) -> None:
        """Set the eps1tf property."""
        self._cards[4].set_value("eps1tf", value)

    @property
    def eps2tf(self) -> float:
        """Get or set the Failure strain in tension along the b-direction.
        """ # nopep8
        return self._cards[4].get_value("eps2tf")

    @eps2tf.setter
    def eps2tf(self, value: float) -> None:
        """Set the eps2tf property."""
        self._cards[4].set_value("eps2tf", value)

    @property
    def eps3tf(self) -> float:
        """Get or set the Failure strain in tension along the c-direction.
        """ # nopep8
        return self._cards[4].get_value("eps3tf")

    @eps3tf.setter
    def eps3tf(self, value: float) -> None:
        """Set the eps3tf property."""
        self._cards[4].set_value("eps3tf", value)

    @property
    def eps1cf(self) -> float:
        """Get or set the Failure strain in compression along the a-direction.
        """ # nopep8
        return self._cards[4].get_value("eps1cf")

    @eps1cf.setter
    def eps1cf(self, value: float) -> None:
        """Set the eps1cf property."""
        self._cards[4].set_value("eps1cf", value)

    @property
    def eps2cf(self) -> float:
        """Get or set the Failure strain in compression along the b-direction.
        """ # nopep8
        return self._cards[4].get_value("eps2cf")

    @eps2cf.setter
    def eps2cf(self, value: float) -> None:
        """Set the eps2cf property."""
        self._cards[4].set_value("eps2cf", value)

    @property
    def eps3cf(self) -> float:
        """Get or set the Failure strain in compression along the c-direction.
        """ # nopep8
        return self._cards[4].get_value("eps3cf")

    @eps3cf.setter
    def eps3cf(self, value: float) -> None:
        """Set the eps3cf property."""
        self._cards[4].set_value("eps3cf", value)

    @property
    def eps12f(self) -> float:
        """Get or set the Failure shear strain in the ab-plane.
        """ # nopep8
        return self._cards[5].get_value("eps12f")

    @eps12f.setter
    def eps12f(self, value: float) -> None:
        """Set the eps12f property."""
        self._cards[5].set_value("eps12f", value)

    @property
    def eps23f(self) -> float:
        """Get or set the Failure shear strain in the bc-plane.
        """ # nopep8
        return self._cards[5].get_value("eps23f")

    @eps23f.setter
    def eps23f(self, value: float) -> None:
        """Set the eps23f property."""
        self._cards[5].set_value("eps23f", value)

    @property
    def eps13f(self) -> float:
        """Get or set the Failure shear strain in the ac-plane.
        """ # nopep8
        return self._cards[5].get_value("eps13f")

    @eps13f.setter
    def eps13f(self, value: float) -> None:
        """Set the eps13f property."""
        self._cards[5].set_value("eps13f", value)

    @property
    def epsd1t(self) -> typing.Optional[float]:
        """Get or set the Damage threshold in tension along the a-direction.
        """ # nopep8
        return self._cards[5].get_value("epsd1t")

    @epsd1t.setter
    def epsd1t(self, value: float) -> None:
        """Set the epsd1t property."""
        self._cards[5].set_value("epsd1t", value)

    @property
    def epsc1t(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in tension along the a-direction.
        """ # nopep8
        return self._cards[5].get_value("epsc1t")

    @epsc1t.setter
    def epsc1t(self, value: float) -> None:
        """Set the epsc1t property."""
        self._cards[5].set_value("epsc1t", value)

    @property
    def cdam1t(self) -> typing.Optional[float]:
        """Get or set the Critical damage in tension along the a-direction.
        """ # nopep8
        return self._cards[5].get_value("cdam1t")

    @cdam1t.setter
    def cdam1t(self, value: float) -> None:
        """Set the cdam1t property."""
        self._cards[5].set_value("cdam1t", value)

    @property
    def epsd2t(self) -> typing.Optional[float]:
        """Get or set the Damage threshold in tension along the b-direction.
        """ # nopep8
        return self._cards[5].get_value("epsd2t")

    @epsd2t.setter
    def epsd2t(self, value: float) -> None:
        """Set the epsd2t property."""
        self._cards[5].set_value("epsd2t", value)

    @property
    def epsc2t(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in tension along the b-direction.
        """ # nopep8
        return self._cards[5].get_value("epsc2t")

    @epsc2t.setter
    def epsc2t(self, value: float) -> None:
        """Set the epsc2t property."""
        self._cards[5].set_value("epsc2t", value)

    @property
    def cdam2t(self) -> float:
        """Get or set the Critical damage in tension along the b-direction.
        """ # nopep8
        return self._cards[6].get_value("cdam2t")

    @cdam2t.setter
    def cdam2t(self, value: float) -> None:
        """Set the cdam2t property."""
        self._cards[6].set_value("cdam2t", value)

    @property
    def epsd3t(self) -> float:
        """Get or set the Damage threshold in tension along the c-direction.
        """ # nopep8
        return self._cards[6].get_value("epsd3t")

    @epsd3t.setter
    def epsd3t(self, value: float) -> None:
        """Set the epsd3t property."""
        self._cards[6].set_value("epsd3t", value)

    @property
    def epsc3t(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in tension along the c-direction.
        """ # nopep8
        return self._cards[6].get_value("epsc3t")

    @epsc3t.setter
    def epsc3t(self, value: float) -> None:
        """Set the epsc3t property."""
        self._cards[6].set_value("epsc3t", value)

    @property
    def cdam3t(self) -> typing.Optional[float]:
        """Get or set the Critical damage in tension along the c-direction.
        """ # nopep8
        return self._cards[6].get_value("cdam3t")

    @cdam3t.setter
    def cdam3t(self, value: float) -> None:
        """Set the cdam3t property."""
        self._cards[6].set_value("cdam3t", value)

    @property
    def epsd1c(self) -> typing.Optional[float]:
        """Get or set the Damage threshold in compression along the a-direction.
        """ # nopep8
        return self._cards[6].get_value("epsd1c")

    @epsd1c.setter
    def epsd1c(self, value: float) -> None:
        """Set the epsd1c property."""
        self._cards[6].set_value("epsd1c", value)

    @property
    def epsc1c(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in compression along the a-direction.
        """ # nopep8
        return self._cards[6].get_value("epsc1c")

    @epsc1c.setter
    def epsc1c(self, value: float) -> None:
        """Set the epsc1c property."""
        self._cards[6].set_value("epsc1c", value)

    @property
    def cdam1c(self) -> typing.Optional[float]:
        """Get or set the Critical damage in compression along the a-direction.
        """ # nopep8
        return self._cards[6].get_value("cdam1c")

    @cdam1c.setter
    def cdam1c(self, value: float) -> None:
        """Set the cdam1c property."""
        self._cards[6].set_value("cdam1c", value)

    @property
    def epsd2c(self) -> typing.Optional[float]:
        """Get or set the Damage threshold in compression along the b-direction.
        """ # nopep8
        return self._cards[6].get_value("epsd2c")

    @epsd2c.setter
    def epsd2c(self, value: float) -> None:
        """Set the epsd2c property."""
        self._cards[6].set_value("epsd2c", value)

    @property
    def epsc2c(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in compression along the b-direction.
        """ # nopep8
        return self._cards[7].get_value("epsc2c")

    @epsc2c.setter
    def epsc2c(self, value: float) -> None:
        """Set the epsc2c property."""
        self._cards[7].set_value("epsc2c", value)

    @property
    def cdam2c(self) -> typing.Optional[float]:
        """Get or set the Critical damage in compression along the b-direction.
        """ # nopep8
        return self._cards[7].get_value("cdam2c")

    @cdam2c.setter
    def cdam2c(self, value: float) -> None:
        """Set the cdam2c property."""
        self._cards[7].set_value("cdam2c", value)

    @property
    def epsd3c(self) -> typing.Optional[float]:
        """Get or set the Damage threshold in compression along the c-direction.
        """ # nopep8
        return self._cards[7].get_value("epsd3c")

    @epsd3c.setter
    def epsd3c(self, value: float) -> None:
        """Set the epsd3c property."""
        self._cards[7].set_value("epsd3c", value)

    @property
    def epsc3c(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold in compression along the c-direction.
        """ # nopep8
        return self._cards[7].get_value("epsc3c")

    @epsc3c.setter
    def epsc3c(self, value: float) -> None:
        """Set the epsc3c property."""
        self._cards[7].set_value("epsc3c", value)

    @property
    def cdam3c(self) -> typing.Optional[float]:
        """Get or set the Critical damage in compression along the c-direction.
        """ # nopep8
        return self._cards[7].get_value("cdam3c")

    @cdam3c.setter
    def cdam3c(self, value: float) -> None:
        """Set the cdam3c property."""
        self._cards[7].set_value("cdam3c", value)

    @property
    def epsd12(self) -> typing.Optional[float]:
        """Get or set the Damage threshold for shear in the ab-plane.
        """ # nopep8
        return self._cards[7].get_value("epsd12")

    @epsd12.setter
    def epsd12(self, value: float) -> None:
        """Set the epsd12 property."""
        self._cards[7].set_value("epsd12", value)

    @property
    def epsc12(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold for shear in the ab-plane.
        """ # nopep8
        return self._cards[7].get_value("epsc12")

    @epsc12.setter
    def epsc12(self, value: float) -> None:
        """Set the epsc12 property."""
        self._cards[7].set_value("epsc12", value)

    @property
    def cdam12(self) -> typing.Optional[float]:
        """Get or set the Critical damage for shear in the ab-plane.
        """ # nopep8
        return self._cards[7].get_value("cdam12")

    @cdam12.setter
    def cdam12(self, value: float) -> None:
        """Set the cdam12 property."""
        self._cards[7].set_value("cdam12", value)

    @property
    def epsd23(self) -> typing.Optional[float]:
        """Get or set the Damage threshold for shear in the bc-plane.
        """ # nopep8
        return self._cards[8].get_value("epsd23")

    @epsd23.setter
    def epsd23(self, value: float) -> None:
        """Set the epsd23 property."""
        self._cards[8].set_value("epsd23", value)

    @property
    def epsc23(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold for shear in the bc-plane.
        """ # nopep8
        return self._cards[8].get_value("epsc23")

    @epsc23.setter
    def epsc23(self, value: float) -> None:
        """Set the epsc23 property."""
        self._cards[8].set_value("epsc23", value)

    @property
    def cdam23(self) -> typing.Optional[float]:
        """Get or set the Critical damage for shear in the bc-plane.
        """ # nopep8
        return self._cards[8].get_value("cdam23")

    @cdam23.setter
    def cdam23(self, value: float) -> None:
        """Set the cdam23 property."""
        self._cards[8].set_value("cdam23", value)

    @property
    def epsd31(self) -> typing.Optional[float]:
        """Get or set the Damage threshold for shear in the ac-plane.
        """ # nopep8
        return self._cards[8].get_value("epsd31")

    @epsd31.setter
    def epsd31(self, value: float) -> None:
        """Set the epsd31 property."""
        self._cards[8].set_value("epsd31", value)

    @property
    def epsc31(self) -> typing.Optional[float]:
        """Get or set the Critical damage threshold for shear in the ac-plane.
        """ # nopep8
        return self._cards[8].get_value("epsc31")

    @epsc31.setter
    def epsc31(self, value: float) -> None:
        """Set the epsc31 property."""
        self._cards[8].set_value("epsc31", value)

    @property
    def cdam31(self) -> typing.Optional[float]:
        """Get or set the Critical damage for shear in the ac-plane.
        """ # nopep8
        return self._cards[8].get_value("cdam31")

    @cdam31.setter
    def cdam31(self, value: float) -> None:
        """Set the cdam31 property."""
        self._cards[8].set_value("cdam31", value)

    @property
    def title(self) -> typing.Optional[str]:
        """Get or set the Additional title line
        """ # nopep8
        return self._cards[9].cards[0].get_value("title")

    @title.setter
    def title(self, value: str) -> None:
        """Set the title property."""
        self._cards[9].cards[0].set_value("title", value)

        if value:
            self.activate_option("TITLE")

