# This an autogenerated file
# 
# Generated with SlenderElement
from __future__ import annotations
from typing import Dict,Sequence,List
from dmt.entity import Entity
from dmt.blueprint import Blueprint
from .blueprints.slenderelement import SlenderElementBlueprint
from typing import Dict
from sima.sima.namedobject import NamedObject
from sima.sima.point3 import Point3
from sima.sima.scriptablevalue import ScriptableValue
from sima.simo.aerodynamicdescription import AerodynamicDescription
from sima.simo.depthdependenthydrodynamiccoefficient import DepthDependenthydrodynamicCoefficient
from sima.simo.loadtype import LoadType
from sima.simo.waveintegrationmethod import WaveIntegrationMethod
from sima.simo.waveparticlemethod import WaveParticleMethod
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from sima.hydro.diffractedwave import DiffractedWave

class SlenderElement(NamedObject):
    """
    Keyword arguments
    -----------------
    name : str
         (default "")
    description : str
         (default "")
    _id : str
         (default "")
    scriptableValues : List[ScriptableValue]
    specificVolume : float
         Specific volume (cross-section area) of element(default 0.0)
    distributedMass : float
         Distributed mass of element(default 0.0)
    waveIntegrationMethod : WaveIntegrationMethod
         Wave force integration method
    loadType : LoadType
         Parameter for load types
    waveParticleMethod : WaveParticleMethod
         Wave particle options
    numberOfStrips : int
         Number of strips(default 10)
    endPoint1 : Point3
    endPoint2 : Point3
    referencePoint : Point3
    zcoef : float
         Vertical position used as reference for depth dependency(default 0.0)
    depthDependentHydrodynamicCoefficients : List[DepthDependenthydrodynamicCoefficient]
    diffractedWaveEnd1 : DiffractedWave
    diffractedWaveEnd2 : DiffractedWave
    c2x : float
         Quadratic drag x(default 0.0)
    c2y : float
         Quadratic drag y(default 0.0)
    c2z : float
         Quadratic drag z(default 0.0)
    c1x : float
         Linear drag x(default 0.0)
    c1y : float
         Linear drag y(default 0.0)
    c1z : float
         Linear drag z(default 0.0)
    amx : float
         Added mass x(default 0.0)
    amy : float
         Added mass y(default 0.0)
    amz : float
         Added mass z(default 0.0)
    windForces : bool
         (default False)
    aerodynamicDescription : AerodynamicDescription
    """

    def __init__(self , name="", description="", _id="", specificVolume=0.0, distributedMass=0.0, waveIntegrationMethod=WaveIntegrationMethod.ACTUAL_WAVE_ELEVATION, loadType=LoadType.GRAVITY_AND_BUOYANCY_INCLUDED, waveParticleMethod=WaveParticleMethod.VELOCITY_AND_ACCELERATION, numberOfStrips=10, zcoef=0.0, c2x=0.0, c2y=0.0, c2z=0.0, c1x=0.0, c1y=0.0, c1z=0.0, amx=0.0, amy=0.0, amz=0.0, windForces=False, **kwargs):
        super().__init__(**kwargs)
        self.name = name
        self.description = description
        self._id = _id
        self.scriptableValues = list()
        self.specificVolume = specificVolume
        self.distributedMass = distributedMass
        self.waveIntegrationMethod = waveIntegrationMethod
        self.loadType = loadType
        self.waveParticleMethod = waveParticleMethod
        self.numberOfStrips = numberOfStrips
        self.endPoint1 = None
        self.endPoint2 = None
        self.referencePoint = None
        self.zcoef = zcoef
        self.depthDependentHydrodynamicCoefficients = list()
        self.diffractedWaveEnd1 = None
        self.diffractedWaveEnd2 = None
        self.c2x = c2x
        self.c2y = c2y
        self.c2z = c2z
        self.c1x = c1x
        self.c1y = c1y
        self.c1z = c1z
        self.amx = amx
        self.amy = amy
        self.amz = amz
        self.windForces = windForces
        self.aerodynamicDescription = None
        for key, value in kwargs.items():
            if not isinstance(value, Dict):
                setattr(self, key, value)


    @property
    def blueprint(self) -> Blueprint:
        """Return blueprint that this entity represents"""
        return SlenderElementBlueprint()


    @property
    def name(self) -> str:
        """"""
        return self.__name

    @name.setter
    def name(self, value: str):
        """Set name"""
        self.__name = str(value)

    @property
    def description(self) -> str:
        """"""
        return self.__description

    @description.setter
    def description(self, value: str):
        """Set description"""
        self.__description = str(value)

    @property
    def _id(self) -> str:
        """"""
        return self.___id

    @_id.setter
    def _id(self, value: str):
        """Set _id"""
        self.___id = str(value)

    @property
    def scriptableValues(self) -> List[ScriptableValue]:
        """"""
        return self.__scriptableValues

    @scriptableValues.setter
    def scriptableValues(self, value: List[ScriptableValue]):
        """Set scriptableValues"""
        if not isinstance(value, Sequence):
            raise Exception("Expected sequense, but was " , type(value))
        self.__scriptableValues = value

    @property
    def specificVolume(self) -> float:
        """Specific volume (cross-section area) of element"""
        return self.__specificVolume

    @specificVolume.setter
    def specificVolume(self, value: float):
        """Set specificVolume"""
        self.__specificVolume = float(value)

    @property
    def distributedMass(self) -> float:
        """Distributed mass of element"""
        return self.__distributedMass

    @distributedMass.setter
    def distributedMass(self, value: float):
        """Set distributedMass"""
        self.__distributedMass = float(value)

    @property
    def waveIntegrationMethod(self) -> WaveIntegrationMethod:
        """Wave force integration method"""
        return self.__waveIntegrationMethod

    @waveIntegrationMethod.setter
    def waveIntegrationMethod(self, value: WaveIntegrationMethod):
        """Set waveIntegrationMethod"""
        self.__waveIntegrationMethod = value

    @property
    def loadType(self) -> LoadType:
        """Parameter for load types"""
        return self.__loadType

    @loadType.setter
    def loadType(self, value: LoadType):
        """Set loadType"""
        self.__loadType = value

    @property
    def waveParticleMethod(self) -> WaveParticleMethod:
        """Wave particle options"""
        return self.__waveParticleMethod

    @waveParticleMethod.setter
    def waveParticleMethod(self, value: WaveParticleMethod):
        """Set waveParticleMethod"""
        self.__waveParticleMethod = value

    @property
    def numberOfStrips(self) -> int:
        """Number of strips"""
        return self.__numberOfStrips

    @numberOfStrips.setter
    def numberOfStrips(self, value: int):
        """Set numberOfStrips"""
        self.__numberOfStrips = int(value)

    @property
    def endPoint1(self) -> Point3:
        """"""
        return self.__endPoint1

    @endPoint1.setter
    def endPoint1(self, value: Point3):
        """Set endPoint1"""
        self.__endPoint1 = value

    @property
    def endPoint2(self) -> Point3:
        """"""
        return self.__endPoint2

    @endPoint2.setter
    def endPoint2(self, value: Point3):
        """Set endPoint2"""
        self.__endPoint2 = value

    @property
    def referencePoint(self) -> Point3:
        """"""
        return self.__referencePoint

    @referencePoint.setter
    def referencePoint(self, value: Point3):
        """Set referencePoint"""
        self.__referencePoint = value

    @property
    def zcoef(self) -> float:
        """Vertical position used as reference for depth dependency"""
        return self.__zcoef

    @zcoef.setter
    def zcoef(self, value: float):
        """Set zcoef"""
        self.__zcoef = float(value)

    @property
    def depthDependentHydrodynamicCoefficients(self) -> List[DepthDependenthydrodynamicCoefficient]:
        """"""
        return self.__depthDependentHydrodynamicCoefficients

    @depthDependentHydrodynamicCoefficients.setter
    def depthDependentHydrodynamicCoefficients(self, value: List[DepthDependenthydrodynamicCoefficient]):
        """Set depthDependentHydrodynamicCoefficients"""
        if not isinstance(value, Sequence):
            raise Exception("Expected sequense, but was " , type(value))
        self.__depthDependentHydrodynamicCoefficients = value

    @property
    def diffractedWaveEnd1(self) -> DiffractedWave:
        """"""
        return self.__diffractedWaveEnd1

    @diffractedWaveEnd1.setter
    def diffractedWaveEnd1(self, value: DiffractedWave):
        """Set diffractedWaveEnd1"""
        self.__diffractedWaveEnd1 = value

    @property
    def diffractedWaveEnd2(self) -> DiffractedWave:
        """"""
        return self.__diffractedWaveEnd2

    @diffractedWaveEnd2.setter
    def diffractedWaveEnd2(self, value: DiffractedWave):
        """Set diffractedWaveEnd2"""
        self.__diffractedWaveEnd2 = value

    @property
    def c2x(self) -> float:
        """Quadratic drag x"""
        return self.__c2x

    @c2x.setter
    def c2x(self, value: float):
        """Set c2x"""
        self.__c2x = float(value)

    @property
    def c2y(self) -> float:
        """Quadratic drag y"""
        return self.__c2y

    @c2y.setter
    def c2y(self, value: float):
        """Set c2y"""
        self.__c2y = float(value)

    @property
    def c2z(self) -> float:
        """Quadratic drag z"""
        return self.__c2z

    @c2z.setter
    def c2z(self, value: float):
        """Set c2z"""
        self.__c2z = float(value)

    @property
    def c1x(self) -> float:
        """Linear drag x"""
        return self.__c1x

    @c1x.setter
    def c1x(self, value: float):
        """Set c1x"""
        self.__c1x = float(value)

    @property
    def c1y(self) -> float:
        """Linear drag y"""
        return self.__c1y

    @c1y.setter
    def c1y(self, value: float):
        """Set c1y"""
        self.__c1y = float(value)

    @property
    def c1z(self) -> float:
        """Linear drag z"""
        return self.__c1z

    @c1z.setter
    def c1z(self, value: float):
        """Set c1z"""
        self.__c1z = float(value)

    @property
    def amx(self) -> float:
        """Added mass x"""
        return self.__amx

    @amx.setter
    def amx(self, value: float):
        """Set amx"""
        self.__amx = float(value)

    @property
    def amy(self) -> float:
        """Added mass y"""
        return self.__amy

    @amy.setter
    def amy(self, value: float):
        """Set amy"""
        self.__amy = float(value)

    @property
    def amz(self) -> float:
        """Added mass z"""
        return self.__amz

    @amz.setter
    def amz(self, value: float):
        """Set amz"""
        self.__amz = float(value)

    @property
    def windForces(self) -> bool:
        """"""
        return self.__windForces

    @windForces.setter
    def windForces(self, value: bool):
        """Set windForces"""
        self.__windForces = bool(value)

    @property
    def aerodynamicDescription(self) -> AerodynamicDescription:
        """"""
        return self.__aerodynamicDescription

    @aerodynamicDescription.setter
    def aerodynamicDescription(self, value: AerodynamicDescription):
        """Set aerodynamicDescription"""
        self.__aerodynamicDescription = value
