How to use the sarpy.io.complex.sicd_elements.base._FloatDescriptor function in sarpy

class LFMEclipseType(Serializable):
    """
    The LFM Eclipse definition.
    """

    _fields = ('FxEarlyLow', 'FxEarlyHigh', 'FxLateLow', 'FxLateHigh')
    _required = _fields
    _numeric_format = {fld: '0.16G' for fld in _fields}
    # descriptors
    FxEarlyLow = _FloatDescriptor(
        'FxEarlyLow', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring=r'FX domain minimum frequency value for an echo at '
                  r':math:`\Delta TOA = \Delta TOAE1 < \Delta TOA1`, in Hz.')  # type: float
    FxEarlyHigh = _FloatDescriptor(
        'FxEarlyHigh', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='FX domain maximum frequency value for an echo at '
                  r':math:`\Delta TOA = \Delta TOAE1 < \Delta TOA1`, in Hz.')  # type: float
    FxLateLow = _FloatDescriptor(
        'FxLateLow', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='FX domain minimum frequency value for an echo at '
                  r':math:`\Delta TOA = \Delta TOAE2 < \Delta TOA2`, in Hz.')  # type: float
    FxLateHigh = _FloatDescriptor(
        'FxLateHigh', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='FX domain maximum frequency value for echo at '
                  r':math:`\Delta TOA = \Delta TOAE2 < \Delta TOA2`, in Hz.')  # type: float

    def __init__(self, FxEarlyLow=None, FxEarlyHigh=None, FxLateLow=None, FxLateHigh=None,
                 **kwargs):
        """

if array is None:
            return None
        if isinstance(array, (numpy.ndarray, list, tuple)):
            if len(array) < 2:
                raise ValueError('Expected array to be of length 2, and received {}'.format(array))
            return cls(Lat=array[0], Lon=array[1])
        raise ValueError('Expected array to be numpy.ndarray, list, or tuple, got {}'.format(type(array)))


class LatLonHAEType(LatLonType):
    """A three-dimensional geographic point in WGS-84 coordinates."""
    _fields = ('Lat', 'Lon', 'HAE')
    _required = _fields
    _numeric_format = {'Lat': '0.16G', 'Lon': '0.16G', 'HAE': '0.16G'}
    # descriptors
    HAE = _FloatDescriptor(
        'HAE', _required, strict=True,
        docstring='The Height Above Ellipsoid (in meters) attribute. Assumed to be '
                  'WGS-84 coordinates.')  # type: float

    def __init__(self, Lat=None, Lon=None, HAE=None, **kwargs):
        """
        Parameters
        ----------
        Lat : float
        Lon : float
        HAE : float
        kwargs : dict
        """

        if '_xml_ns' in kwargs:
            self._xml_ns = kwargs['_xml_ns']

# descriptors
    TxPulseLength = _FloatDescriptor(
        'TxPulseLength', _required, strict=DEFAULT_STRICT,
        docstring='Transmit pulse length in seconds.')  # type: float
    TxRFBandwidth = _FloatDescriptor(
        'TxRFBandwidth', _required, strict=DEFAULT_STRICT,
        docstring='Transmit RF bandwidth of the transmit pulse in Hz.')  # type: float
    TxFreqStart = _FloatDescriptor(
        'TxFreqStart', _required, strict=DEFAULT_STRICT,
        docstring='Transmit Start frequency for Linear FM waveform in Hz, may be relative '
                  'to reference frequency.')  # type: float
    TxFMRate = _FloatDescriptor(
        'TxFMRate', _required, strict=DEFAULT_STRICT,
        docstring='Transmit FM rate for Linear FM waveform in Hz/second.')  # type: float
    RcvWindowLength = _FloatDescriptor(
        'RcvWindowLength', _required, strict=DEFAULT_STRICT,
        docstring='Receive window duration in seconds.')  # type: float
    ADCSampleRate = _FloatDescriptor(
        'ADCSampleRate', _required, strict=DEFAULT_STRICT,
        docstring='Analog-to-Digital Converter sampling rate in samples/second.')  # type: float
    RcvIFBandwidth = _FloatDescriptor(
        'RcvIFBandwidth', _required, strict=DEFAULT_STRICT,
        docstring='Receive IF bandwidth in Hz.')  # type: float
    RcvFreqStart = _FloatDescriptor(
        'RcvFreqStart', _required, strict=DEFAULT_STRICT,
        docstring='Receive demodulation start frequency in Hz, may be relative to reference frequency.')  # type: float
    index = _IntegerDescriptor(
        'index', _required, strict=False, docstring="The array index.")  # type: int

    def __init__(self, TxPulseLength=None, TxRFBandwidth=None, TxFreqStart=None, TxFMRate=None,
                 RcvDemodType=None, RcvWindowLength=None, ADCSampleRate=None, RcvIFBandwidth=None,

'TOASavedNom': '0.16G'}
    # descriptors
    SRP_Index = _IntegerDescriptor(
        'SRP_Index', _required, strict=DEFAULT_STRICT,
        docstring='Index to identify the SRP position function used for the '
                  'channel.')  # type: int
    NomTOARateSF = _FloatDescriptor(
        'NomTOARateSF', _required, strict=DEFAULT_STRICT,
        docstring='Scale factor to indicate the fraction of the Doppler spectrum '
                  'that is clear.')  # type: float
    FxCtrNom = _FloatDescriptor(
        'FxCtrNom', _required, strict=DEFAULT_STRICT,
        docstring='Nominal center transmit frequency associated with the channel (Hz). '
                  'For DomainType = TOA, FxCtrNom is the center frequency for all '
                  'vectors.')  # type: float
    BWSavedNom = _FloatDescriptor(
        'BWSavedNom', _required, strict=DEFAULT_STRICT,
        docstring='Nominal transmit bandwidth associated with the channel (Hz). '
                  'For DomainType = TOA, BWSavedNom is the bandwidth saved for all '
                  'vectors.')  # type: float
    TOASavedNom = _FloatDescriptor(
        'TOASavedNom', _required, strict=DEFAULT_STRICT,
        docstring='Nominal span in TOA saved for the channel. For DomainType = FX, '
                  'TOASavedNom is the bandwidth saved for all '
                  'vectors.')  # type: float
    TxAnt_Index = _IntegerDescriptor(
        'TxAnt_Index', _required, strict=DEFAULT_STRICT,
        docstring='Indicates the Transmit Antenna pattern for data collected to form '
                  'the CPHD channel.')  # type: Union[None, int]
    RcvAnt_Index = _IntegerDescriptor(
        'RcvAnt_Index', _required, strict=DEFAULT_STRICT,
        docstring='Indicates the Receive Antenna pattern for data collected to form '

class RadarSensorErrorType(Serializable):
    """Radar sensor error statistics."""
    _fields = ('RangeBias', 'ClockFreqSF', 'TransmitFreqSF', 'RangeBiasDecorr')
    _required = ('RangeBias', )
    _numeric_format = {'RangeBias': '0.16G', 'ClockFreqSF': '0.16G', 'TransmitFreqSF': '0.16G'}
    # descriptors
    RangeBias = _FloatDescriptor(
        'RangeBias', _required, strict=DEFAULT_STRICT,
        docstring='Range bias error standard deviation.')  # type: float
    ClockFreqSF = _FloatDescriptor(
        'ClockFreqSF', _required, strict=DEFAULT_STRICT,
        docstring='Payload clock frequency scale factor standard deviation, '
                  r'where :math:`SF = (\Delta f)/f_0`.')  # type: float
    TransmitFreqSF = _FloatDescriptor(
        'TransmitFreqSF', _required, strict=DEFAULT_STRICT,
        docstring='Transmit frequency scale factor standard deviation, '
                  r'where :math:`SF = (\Delta f)/f_0`.')  # type: float
    RangeBiasDecorr = _SerializableDescriptor(
        'RangeBiasDecorr', ErrorDecorrFuncType, _required, strict=DEFAULT_STRICT,
        docstring='Range bias decorrelation rate.')  # type: ErrorDecorrFuncType

    def __init__(self, RangeBias=None, ClockFreqSF=None, TransmitFreqSF=None, RangeBiasDecorr=None, **kwargs):
        """

        Parameters
        ----------
        RangeBias : float
        ClockFreqSF : float
        TransmitFreqSF : float
        RangeBiasDecorr : ErrorDecorrFuncType

"""

    _fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS', 'NODATA')
    _required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS')
    _numeric_format = {'X0': '0.16G', 'Y0': '0.16G', 'XSS': '0.16G', 'YSS': '0.16G'}
    # descriptors
    Identifier = _StringDescriptor(
        'Identifier', _required, strict=DEFAULT_STRICT,
        docstring='The support array identifier.')  # type: str
    ElementFormat = _StringDescriptor(
        'ElementFormat', _required, strict=DEFAULT_STRICT,
        docstring='The data element format.')  # type: str
    X0 = _FloatDescriptor(
        'X0', _required, strict=DEFAULT_STRICT,
        docstring='')  # type: float
    Y0 = _FloatDescriptor(
        'Y0', _required, strict=DEFAULT_STRICT,
        docstring='')  # type: float
    XSS = _FloatDescriptor(
        'XSS', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='')  # type: float
    YSS = _FloatDescriptor(
        'YSS', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='')  # type: float

    def __init__(self, Identifier=None, ElementFormat=None, X0=None, Y0=None,
                 XSS=None, YSS=None, NODATA=None, **kwargs):
        """

        Parameters
        ----------
        Identifier : str

PolarAngPoly = _SerializableDescriptor(
        'PolarAngPoly', Poly1DType, _required, strict=DEFAULT_STRICT,
        docstring='Polynomial function that yields Polar Angle *(in radians)* as function of time '
                  'relative to Collection Start.')  # type: Poly1DType
    SpatialFreqSFPoly = _SerializableDescriptor(
        'SpatialFreqSFPoly', Poly1DType, _required, strict=DEFAULT_STRICT,
        docstring='Polynomial that yields the *Spatial Frequency Scale Factor (KSF)* as a function of Polar '
                  r'Angle. That is, :math:`Polar Angle[radians] \to KSF[dimensionless]`. Used to scale RF '
                  'frequency *(fx, Hz)* to aperture spatial frequency *(Kap, cycles/m)*. Where,'
                  r':math:`Kap = fx\cdot (2/c)\cdot KSF`, and `Kap` is the effective spatial '
                  'frequency in the polar aperture.')  # type: Poly1DType
    Krg1 = _FloatDescriptor(
        'Krg1', _required, strict=DEFAULT_STRICT,
        docstring='Minimum *range spatial frequency (Krg)* output from the polar to rectangular '
                  'resampling.')  # type: float
    Krg2 = _FloatDescriptor(
        'Krg2', _required, strict=DEFAULT_STRICT,
        docstring='Maximum *range spatial frequency (Krg)* output from the polar to rectangular '
                  'resampling.')  # type: float
    Kaz1 = _FloatDescriptor(
        'Kaz1', _required, strict=DEFAULT_STRICT,
        docstring='Minimum *azimuth spatial frequency (Kaz)* output from the polar to rectangular '
                  'resampling.')  # type: float
    Kaz2 = _FloatDescriptor(
        'Kaz2', _required, strict=DEFAULT_STRICT,
        docstring='Maximum *azimuth spatial frequency (Kaz)* output from the polar to rectangular '
                  'resampling.')  # type: float
    StDeskew = _SerializableDescriptor(
        'StDeskew', STDeskewType, _required, strict=DEFAULT_STRICT,
        docstring='Parameters to describe image domain slow time *(ST)* Deskew processing.')  # type: STDeskewType

    def __init__(self, FPN=None, IPN=None, PolarAngRefTime=None, PolarAngPoly=None,

'P1P2', 'P1P3', 'P1V1', 'P1V2', 'P1V3', 'P2P3', 'P2V1', 'P2V2', 'P2V3',
        'P3V1', 'P3V2', 'P3V3', 'V1V2', 'V1V3', 'V2V3')
    _required = _fields
    _numeric_format = {key: '0.16G' for key in _fields}
    # descriptors
    P1P2 = _FloatDescriptor(
        'P1P2', _required, strict=DEFAULT_STRICT, docstring='`P1` and `P2` correlation coefficient.')  # type: float
    P1P3 = _FloatDescriptor(
        'P1P3', _required, strict=DEFAULT_STRICT, docstring='`P1` and `P3` correlation coefficient.')  # type: float
    P1V1 = _FloatDescriptor(
        'P1V1', _required, strict=DEFAULT_STRICT, docstring='`P1` and `V1` correlation coefficient.')  # type: float
    P1V2 = _FloatDescriptor(
        'P1V2', _required, strict=DEFAULT_STRICT, docstring='`P1` and `V2` correlation coefficient.')  # type: float
    P1V3 = _FloatDescriptor(
        'P1V3', _required, strict=DEFAULT_STRICT, docstring='`P1` and `V3` correlation coefficient.')  # type: float
    P2P3 = _FloatDescriptor(
        'P2P3', _required, strict=DEFAULT_STRICT, docstring='`P2` and `P3` correlation coefficient.')  # type: float
    P2V1 = _FloatDescriptor(
        'P2V1', _required, strict=DEFAULT_STRICT, docstring='`P2` and `V1` correlation coefficient.')  # type: float
    P2V2 = _FloatDescriptor(
        'P2V2', _required, strict=DEFAULT_STRICT, docstring='`P2` and `V2` correlation coefficient.')  # type: float
    P2V3 = _FloatDescriptor(
        'P2V3', _required, strict=DEFAULT_STRICT, docstring='`P2` and `V3` correlation coefficient.')  # type: float
    P3V1 = _FloatDescriptor(
        'P3V1', _required, strict=DEFAULT_STRICT, docstring='`P3` and `V1` correlation coefficient.')  # type: float
    P3V2 = _FloatDescriptor(
        'P3V2', _required, strict=DEFAULT_STRICT, docstring='`P3` and `V2` correlation coefficient.')  # type: float
    P3V3 = _FloatDescriptor(
        'P3V3', _required, strict=DEFAULT_STRICT, docstring='`P3` and `V3` correlation coefficient.')  # type: float
    V1V2 = _FloatDescriptor(
        'V1V2', _required, strict=DEFAULT_STRICT, docstring='`V1` and `V2` correlation coefficient.')  # type: float
    V1V3 = _FloatDescriptor(

'LFMRate', 'Polarization', 'PathGain')
    _required = (
        'Identifier', 'WindowLength', 'SampleRate', 'IFFilterBW', 'FreqCenter',
        'Polarization')
    _numeric_format = {
        'WindowLength': '0.16G', 'SampleRate': '0.16G', 'IFFilterBW': '0.16G',
        'FreqCenter': '0.16G', 'LFMRate': '0.16G', 'PathGain': '0.16G'}
    # descriptors
    Identifier = _StringDescriptor(
        'Identifier', _required, strict=DEFAULT_STRICT,
        docstring='String that uniquely identifies this Receive '
                  'configuration.')  # type: str
    WindowLength = _FloatDescriptor(
        'WindowLength', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Length of the receive window, in seconds.')  # type: float
    SampleRate = _FloatDescriptor(
        'SampleRate', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Rate at which the signal in the receive window is sampled, '
                  'in Hz.')  # type: float
    IFFilterBW = _FloatDescriptor(
        'IFFilterBW', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Bandwidth of the anti-aliasing filter prior to '
                  'sampling.')  # type: float
    FreqCenter = _FloatDescriptor(
        'FreqCenter', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Center frequency of the demodulation signal, '
                  'in Hz.')  # type: float
    LFMRate = _FloatDescriptor(
        'LFMRate', _required, strict=DEFAULT_STRICT,
        docstring='Chirp rate of the demodulation signal if LFM, '
                  'in Hz/s.')  # type: Union[None, float]
    Polarization = _StringEnumDescriptor(

'SideOfTrack', 'SlantRange', 'GroundRange', 'DopplerConeAngle',
        'GrazeAngle', 'IncidenceAngle', 'AzimuthAngle',
        'TwistAngle', 'SlopeAngle', 'LayoverAngle')
    _required = _fields
    _numeric_format = {
        'SlantRange': '0.16G', 'GroundRange': '0.16G', 'DopplerConeAngle': '0.16G',
        'GrazeAngle': '0.16G', 'IncidenceAngle': '0.16G', 'AzimuthAngle': '0.16G',
        'TwistAngle': '0.16G', 'SlopeAngle': '0.16G', 'LayoverAngle': '0.16G'}
    # descriptors
    ARPPos = _SerializableDescriptor(
        'ARPPos', XYZType, _required, strict=DEFAULT_STRICT,
        docstring='ARP position in ECF coordinates.')  # type: XYZType
    ARPVel = _SerializableDescriptor(
        'ARPVel', XYZType, _required, strict=DEFAULT_STRICT,
        docstring='ARP velocity in ECF coordinates.')  # type: XYZType
    TwistAngle = _FloatDescriptor(
        'TwistAngle', _required, strict=DEFAULT_STRICT, bounds=(-90, 90),
        docstring='Twist angle between cross range in the ETP and cross range in '
                  'the slant plane at the SRP.')  # type: float
    SlopeAngle = _FloatDescriptor(
        'SlopeAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 90),
        docstring='Angle between the ETP normal (uUP) and the slant plane normal '
                  '(uSPN) at the SRP.')  # type: float
    LayoverAngle = _FloatDescriptor(
        'LayoverAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 360),
        docstring='Angle from north to the layover direction in the ETP. Measured '
                  'clockwise from +North toward +East.')  # type: float

    def __init__(self, ARPPos=None, ARPVel=None,
                 SideOfTrack=None, SlantRange=None, GroundRange=None, DopplerConeAngle=None,
                 GrazeAngle=None, IncidenceAngle=None, AzimuthAngle=None,
                 TwistAngle=None, SlopeAngle=None, LayoverAngle=None, **kwargs):