class UnmodeledType(Serializable):
_fields = ('Xrow', 'Ycol', 'XrowYcol', 'UnmodeledDecorr')
_required = ('Xrow', 'Ycol', 'XrowYcol')
_numeric_format = {fld: '0.17G' for fld in ('Xrow', 'Ycol', 'XrowYcol')}
Xrow = FloatDescriptor('Xrow', _required,
strict=DEFAULT_STRICT) # type: float
Ycol = FloatDescriptor('Ycol', _required,
strict=DEFAULT_STRICT) # type: float
XrowYcol = FloatDescriptor('XrowYcol', _required,
strict=DEFAULT_STRICT) # type: float
UnmodeledDecorr = SerializableDescriptor(
'UnmodeledDecorr',
UnmodeledDecorrType,
_required,
strict=DEFAULT_STRICT) # type: Union[None, UnmodeledDecorrType]
def __init__(self,
Xrow=None,
Ycol=None,
XrowYcol=None,
UnmodeledDecorr=None,
**kwargs):
"""
Parameters
----------
Xrow : float
Ycol : float
XrowYcol : float
UnmodeledDecorr : None|UnmodeledDecorrType
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Xrow = Xrow
self.Ycol = Ycol
self.XrowYcol = XrowYcol
self.UnmodeledDecorr = UnmodeledDecorr
super(UnmodeledType, self).__init__(**kwargs)
class TimelineType(Serializable):
"""
Parameters that describe the collection times for the data contained in the product.
"""
_fields = ('CollectionRefTime', 'RcvTime1', 'RcvTime2')
_required = ('CollectionRefTime', 'RcvTime1', 'RcvTime2')
_numeric_format = {'RcvTime1': FLOAT_FORMAT, 'RcvTime2': FLOAT_FORMAT}
# descriptors
CollectionRefTime = DateTimeDescriptor(
'CollectionRefTime', _required, strict=DEFAULT_STRICT, numpy_datetime_units='us',
docstring='Collection Reference Time (t_CRT). Time reference used for all receive times'
' and all transmit times. All times are specified in seconds relative to t_CRT'
' (i.e., t_CRT is slow time t = 0).') # type: numpy.datetime64
RcvTime1 = FloatDescriptor(
'RcvTime1', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Earliest RcvTime value for any signal vector in the product.'
' Time relative to Collection Reference Time.') # type: float
RcvTime2 = FloatDescriptor(
'RcvTime2', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Latest RcvTime value for any signal vector in the product.'
' Time relative to Collection Reference Time.') # type: float
def __init__(self, CollectionRefTime=None, RcvTime1=None, RcvTime2=None, **kwargs):
"""
Parameters
----------
CollectionRefTime : numpy.datetime64|datetime|date|str
RcvTime1 : float
RcvTime2 : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.CollectionRefTime = CollectionRefTime
self.RcvTime1 = RcvTime1
self.RcvTime2 = RcvTime2
super(TimelineType, self).__init__(**kwargs)
class NoiseLevelType(Serializable):
"""
The thermal noise level information.
"""
_fields = ('PNCRSD', 'BNCRSD')
_required = _fields
_numeric_format = {fld: '0.16G' for fld in _fields}
# descriptors
PNCRSD = FloatDescriptor(
'PNCRSD',
_required,
strict=DEFAULT_STRICT,
docstring=
'Noise power level in fast time signal vector for f_IC(v,t) = f_0(v_CH_REF).'
) # type: float
BNCRSD = FloatDescriptor(
'BNCRSD',
_required,
strict=DEFAULT_STRICT,
docstring=
'Noise Equivalent BW for the noise signal. Bandwidth BN_CRSD is expressed relative'
' to the fast time sample rate for the channel (fs).') # type:float
def __init__(self, PNCRSD=None, BNCRSD=None, **kwargs):
"""
Parameters
----------
PNCRSD : float
BNCRSD : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.PNCRSD = PNCRSD
self.BNCRSD = BNCRSD
super(NoiseLevelType, self).__init__(**kwargs)
class BistaticRadarSensorType(Serializable):
"""
Error statistics for a single radar platform.
"""
_fields = ('ClockFreqSF', 'CollectionStartTime')
_required = ('CollectionStartTime', )
_numeric_format = {'ClockFreqSF': '0.16G', 'CollectionStartTime': '0.16G'}
# descriptors
ClockFreqSF = FloatDescriptor(
'ClockFreqSF',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Payload clock frequency scale factor standard deviation, '
r'where :math:`SF = (\Delta f)/f_0`.') # type: float
CollectionStartTime = FloatDescriptor(
'CollectionStartTime',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Collection Start time error standard deviation, '
'in seconds.') # type: float
def __init__(self, ClockFreqSF=None, CollectionStartTime=None, **kwargs):
"""
Parameters
----------
ClockFreqSF : float
CollectionStartTime : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ClockFreqSF = ClockFreqSF
self.CollectionStartTime = CollectionStartTime
super(BistaticRadarSensorType, self).__init__(**kwargs)
class ReferencePointType(Serializable):
"""The reference point definition"""
_fields = ('ECF', 'Line', 'Sample', 'name')
_required = ('ECF', 'Line', 'Sample')
_set_as_attribute = ('name', )
_numeric_format = {'Line': FLOAT_FORMAT, 'Sample': FLOAT_FORMAT}
# descriptors
ECF = SerializableDescriptor(
'ECF', XYZType, _required, strict=DEFAULT_STRICT,
docstring='The geographical coordinates for the reference point.') # type: XYZType
Line = FloatDescriptor(
'Line', _required, strict=DEFAULT_STRICT,
docstring='The reference point line index.') # type: float
Sample = FloatDescriptor(
'Sample', _required, strict=DEFAULT_STRICT,
docstring='The reference point sample index.') # type: float
name = StringDescriptor(
'name', _required, strict=DEFAULT_STRICT,
docstring='The reference point name.') # type: str
def __init__(self, ECF=None, Line=None, Sample=None, name=None, **kwargs):
"""
Parameters
----------
ECF : XYZType|numpy.ndarray|list|tuple
Line : float
Sample : float
name : str
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ECF = ECF
self.Line = Line
self.Sample = Sample
self.name = name
super(ReferencePointType, self).__init__(**kwargs)
class IonoParametersType(Serializable):
"""
Parameters used to compute propagation effects due to the ionosphere.
"""
_fields = ('TECV', 'F2Height')
_required = ('TECV', )
_numeric_format = {fld: FLOAT_FORMAT for fld in _fields}
# descriptor
TECV = FloatDescriptor(
'TECV',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Total Electron Content (TEC) integrated along TECU the Vertical (V), '
r'in units where :math:`1 TECU = 10^{16} e^{-}/m^{2}`') # type: float
F2Height = FloatDescriptor('F2Height',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='The F2 height of the ionosphere, in '
'meters.') # type: Union[None, float]
def __init__(self, TECV=None, F2Height=None, **kwargs):
"""
Parameters
----------
TECV : float
F2Height : None|float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.TECV = TECV
self.F2Height = F2Height
super(IonoParametersType, self).__init__(**kwargs)
class ReceiveSensorType(Serializable):
"""
Receive sensor error statistics
"""
_fields = ('RcvDelayBias', 'ClockFreqSF', 'RefTimeError')
_required = ('RcvDelayBias', )
_numeric_format = {'ClockFreqSF': FLOAT_FORMAT, 'RefTimeError': FLOAT_FORMAT}
# descriptors
RcvDelayBias = FloatDescriptor(
'RcvDelayBias', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Receive path signal delay error bias that causes an error in the'
' estimated signal time of arrival at the Receive APC') # type: float
ClockFreqSF = FloatDescriptor(
'ClockFreqSF', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Payload clock frequency scale factor standard deviation, '
r'where :math:`SF = (\Delta f)/f_0`.') # type: float
RefTimeError = FloatDescriptor(
'RefTimeError', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Time error standard deviation, in seconds.') # type: float
def __init__(self, RcvDelayBias=None, ClockFreqSF=None, RefTimeError=None, **kwargs):
"""
Parameters
----------
RcvDelayBias : float
ClockFreqSF : None|float
RefTimeError : None|float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.RcvDelayBias = RcvDelayBias
self.ClockFreqSF = ClockFreqSF
self.RefTimeError = RefTimeError
super(ReceiveSensorType, self).__init__(**kwargs)
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
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.RangeBias, self.ClockFreqSF, self.TransmitFreqSF = RangeBias, ClockFreqSF, TransmitFreqSF
self.RangeBiasDecorr = RangeBiasDecorr
super(RadarSensorErrorType, self).__init__(**kwargs)
class RMRefType(Serializable):
"""
Range migration reference element of RMA type.
"""
_fields = ('PosRef', 'VelRef', 'DopConeAngRef')
_required = _fields
_numeric_format = {
'DopConeAngRef': FLOAT_FORMAT,
}
# descriptors
PosRef = SerializableDescriptor(
'PosRef',
XYZType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Platform reference position in ECF coordinates used to establish '
'the reference slant plane.') # type: XYZType
VelRef = SerializableDescriptor(
'VelRef',
XYZType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Platform reference velocity vector in ECF coordinates used to establish '
'the reference slant plane.') # type: XYZType
DopConeAngRef = FloatDescriptor(
'DopConeAngRef',
_required,
strict=DEFAULT_STRICT,
docstring='Reference Doppler Cone Angle in degrees.') # type: float
def __init__(self, PosRef=None, VelRef=None, DopConeAngRef=None, **kwargs):
"""
Parameters
----------
PosRef : XYZType|numpy.ndarray|list|tuple
VelRef : XYZType|numpy.ndarray|list|tuple
DopConeAngRef : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.PosRef = PosRef
self.VelRef = VelRef
self.DopConeAngRef = DopConeAngRef
super(RMRefType, self).__init__(**kwargs)
class MonitorCompensationAppliedType(Serializable):
"""
"""
_fields = ('Gamma', 'XMin')
_required = ('Gamma', 'XMin')
_numeric_format = {key: '0.16G' for key in _fields}
# Descriptor
Gamma = FloatDescriptor(
'Gamma',
_required,
strict=DEFAULT_STRICT,
docstring=
'Gamma value for monitor compensation pre-applied to the image.'
) # type: float
XMin = FloatDescriptor(
'XMin',
_required,
strict=DEFAULT_STRICT,
docstring='Xmin value for monitor compensation pre-applied to the image.'
) # type: float
def __init__(self, Gamma=None, XMin=None, **kwargs):
"""
Parameters
----------
Gamma : float
XMin : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Gamma = Gamma
self.XMin = XMin
super(MonitorCompensationAppliedType, self).__init__(**kwargs)
class GeographicCoordinatesType(Serializable):
"""
Describes the Local Geographic Coordinate system linking row/column to the absolute
geographic coordinate (lat/lon).
"""
_fields = ('LongitudeDensity', 'LatitudeDensity', 'ReferenceOrigin')
_required = ('LongitudeDensity', 'LatitudeDensity', 'ReferenceOrigin')
_numeric_format = {'LongitudeDensity': '0.16G', 'LatitudeDensity': '0.16G'}
# Descriptor
LongitudeDensity = FloatDescriptor(
'LongitudeDensity', _required, strict=DEFAULT_STRICT,
docstring='Pixel ground spacing in E/W direction that is the number of pixels '
'or element intervals in 360 degrees.') # type: float
LatitudeDensity = FloatDescriptor(
'LatitudeDensity', _required, strict=DEFAULT_STRICT,
docstring='Pixel ground spacing in N/S direction that is the number of pixels '
'or element intervals in 360 degrees.') # type: float
ReferenceOrigin = SerializableDescriptor(
'ReferenceOrigin', LatLonType, _required, strict=DEFAULT_STRICT,
docstring='Northwest corner Latitude/Longitude - product NW corner') # type: LatLonType
def __init__(self, LongitudeDensity=None, LatitudeDensity=None, ReferenceOrigin=None, **kwargs):
"""
Parameters
----------
LongitudeDensity : float
LatitudeDensity : float
ReferenceOrigin : LatLonType|numpy.ndarray|list|tuple
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
self.LongitudeDensity = LongitudeDensity
self.LatitudeDensity = LatitudeDensity
self.ReferenceOrigin = ReferenceOrigin
super(GeographicCoordinatesType, self).__init__(**kwargs)
class HPBWType(Serializable):
"""
Half power beamwidth parameters.
"""
_fields = ('DCX', 'DCY')
_required = _fields
_numeric_format = {'DCX': '0.16G', 'DCY': '0.16G'}
# descriptors
DCX = FloatDescriptor(
'DCX',
_required,
strict=DEFAULT_STRICT,
docstring='Half power beamwidth in the X-axis direction cosine '
'(DCX).') # type: float
DCY = FloatDescriptor(
'DCY',
_required,
strict=DEFAULT_STRICT,
docstring='Half power beamwidth in the Y -axis direction cosine '
'(DCY).') # type: float
def __init__(self, DCX=None, DCY=None, **kwargs):
"""
Parameters
----------
DCX : float
DCY : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.DCX = DCX
self.DCY = DCY
super(HPBWType, self).__init__(**kwargs)
class DRAOverridesType(Serializable):
"""
The dynamic range adjustment overrides.
"""
_fields = ('Subtractor', 'Multiplier')
_required = _fields
_numeric_format = {key: FLOAT_FORMAT for key in _fields}
# Descriptor
Subtractor = FloatDescriptor(
'Subtractor',
_required,
strict=DEFAULT_STRICT,
bounds=(0, 2047),
docstring='Subtractor value used to reduce haze in the image.'
) # type: float
Multiplier = FloatDescriptor(
'Multiplier',
_required,
strict=DEFAULT_STRICT,
bounds=(0, 2047),
docstring='Multiplier value used to reduce haze in the image.'
) # type: float
def __init__(self, Subtractor=None, Multiplier=None, **kwargs):
"""
Parameters
----------
Subtractor : float
Multiplier : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Subtractor = Subtractor
self.Multiplier = Multiplier
super(DRAOverridesType, self).__init__(**kwargs)
class GainPhaseArrayType(Serializable):
"""
Parameters that identify 2-D sampled Gain & Phase patterns at single
frequency value.
"""
_fields = ('Freq', 'ArrayId', 'ElementId')
_required = ('Freq', 'ArrayId')
_numeric_format = {'Freq', '0.16G'}
# descriptors
Freq = FloatDescriptor(
'Freq',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Frequency value for which the sampled Array and Element '
'pattern(s) are provided, in Hz.') # type: float
ArrayId = StringDescriptor(
'ArrayId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the array '
'at ref Frequency.') # type: str
ElementId = StringDescriptor(
'ElementId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the element '
'at ref frequency.') # type: str
def __init__(self, Freq=None, ArrayId=None, ElementId=None, **kwargs):
"""
Parameters
----------
Freq : float
ArrayId : str
ElementId : None|str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Freq = Freq
self.ArrayId = ArrayId
self.ElementId = ElementId
super(GainPhaseArrayType, self).__init__(**kwargs)
class LocationType(Serializable):
_fields = ('Lat', 'Lon', 'Name')
_required = ('Lat', 'Lon')
# descriptors
Lat = FloatDescriptor(
'Lat',
_required,
strict=DEFAULT_STRICT,
docstring="General latitude of the data collection.") # type: float
Lon = FloatDescriptor(
'Lon',
_required,
strict=DEFAULT_STRICT,
docstring="General longitude of the data collection.") # type: float
Name = StringDescriptor('Name',
_required,
docstring="Common name of the collection location."
) # type: Optional[str]
def __init__(self, Lat=None, Lon=None, Name=None, **kwargs):
"""
Parameters
----------
Lat : float
Lon : float
Name : None|str
kwargs
Other keyword arguments
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Lat = Lat
self.Lon = Lon
self.Name = Name
super(LocationType, self).__init__(**kwargs)
class SpheroidType(Serializable):
"""
"""
_fields = ('SpheroidName', 'SemiMajorAxis', 'InverseFlattening')
_required = _fields
_numeric_format = {'SemiMajorAxis': '0.16G', 'InverseFlattening': '0.16G'}
# Descriptor
SpheroidName = StringDescriptor(
'SpheroidName', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
SemiMajorAxis = FloatDescriptor(
'SemiMajorAxis', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
InverseFlattening = FloatDescriptor(
'InverseFlattening', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
def __init__(self, SpheroidName=None, SemiMajorAxis=None, InverseFlattening=None, **kwargs):
"""
Parameters
----------
SpheroidName : str
SemiMajorAxis : float
InverseFlattening : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.SpheroidName = SpheroidName
self.SemiMajorAxis = SemiMajorAxis
self.InverseFlattening = InverseFlattening
super(SpheroidType, self).__init__(**kwargs)
class IAYExtentType(Serializable):
"""
Increasing sample index is in the +IAY direction.
"""
_fields = ('SampleSpacing', 'FirstSample', 'NumSamples')
_required = _fields
_numeric_format = {'SampleSpacing': '0.16G'}
# descriptors
SampleSpacing = FloatDescriptor(
'SampleSpacing',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Sample spacing, in meters.') # type: float
FirstSample = IntegerDescriptor(
'FirstSample',
_required,
strict=DEFAULT_STRICT,
docstring='Index of the first sample.') # type: int
NumSamples = IntegerDescriptor('NumSamples',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='Number of samples.') # type: int
def __init__(self,
SampleSpacing=None,
FirstSample=None,
NumSamples=None,
**kwargs):
"""
Parameters
----------
SampleSpacing : float
FirstSample : int
NumSamples : int
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.SampleSpacing = SampleSpacing
self.FirstSample = FirstSample
self.NumSamples = NumSamples
super(IAYExtentType, self).__init__(**kwargs)
class SignalRefLevelType(Serializable):
"""
The signal power level information.
"""
_fields = ('PSCRSD', 'PRcvDensity')
_required = _fields
_numeric_format = {fld: FLOAT_FORMAT for fld in _fields}
# descriptors
PSCRSD = FloatDescriptor(
'PSCRSD', _required, strict=DEFAULT_STRICT,
docstring='Power level in the fast time signal vector for a CW tone at f = f_0_REF'
' and for f_IC(v,t) = f_0_REF.') # type: float
PRcvDensity = FloatDescriptor(
'PRcvDensity', _required, strict=DEFAULT_STRICT,
docstring='Receive power density per unit area for a CW tone at f = f_0_REF that results in'
' signal vector power PS_CRSD. Signal received from a far field source located'
' along the receive antenna mainlobe boresight at t = trs(v_CH_REF).') # type:float
def __init__(self, PSCRSD=None, PRcvDensity=None, **kwargs):
"""
Parameters
----------
PSCRSD : float
PRcvDensity : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.PSCRSD = PSCRSD
self.PRcvDensity = PRcvDensity
super(SignalRefLevelType, self).__init__(**kwargs)
class TropoErrorType(Serializable):
"""Troposphere delay error statistics."""
_fields = ('TropoRangeVertical', 'TropoRangeSlant', 'TropoRangeDecorr')
_required = ()
_numeric_format = {'TropoRangeVertical': '0.16G', 'TropoRangeSlant': '0.16G'}
# descriptors
TropoRangeVertical = FloatDescriptor(
'TropoRangeVertical', _required, strict=DEFAULT_STRICT,
docstring='Troposphere two-way delay error for normal incidence standard deviation. '
r'Expressed as a range error. :math:`(\Delta R) = (\Delta T) \cdot (c/2)`.') # type: float
TropoRangeSlant = FloatDescriptor(
'TropoRangeSlant', _required, strict=DEFAULT_STRICT,
docstring='Troposphere two-way delay error for the *SCP* line of sight at *COA* standard deviation. '
r'Expressed as a range error. :math:`(\Delta R) = (\Delta T) \cdot (c/2)`.') # type: float
TropoRangeDecorr = SerializableDescriptor(
'TropoRangeDecorr', ErrorDecorrFuncType, _required, strict=DEFAULT_STRICT,
docstring='Troposphere range error decorrelation function.') # type: ErrorDecorrFuncType
def __init__(self, TropoRangeVertical=None, TropoRangeSlant=None, TropoRangeDecorr=None, **kwargs):
"""
Parameters
----------
TropoRangeVertical : float
TropoRangeSlant : float
TropoRangeDecorr : ErrorDecorrFuncType
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.TropoRangeVertical, self.TropoRangeSlant = TropoRangeVertical, TropoRangeSlant
self.TropoRangeDecorr = TropoRangeDecorr
super(TropoErrorType, self).__init__(**kwargs)
class CompositeSCPErrorType(Serializable):
"""
Composite error statistics for the Scene Center Point. Slant plane range *(Rg)*
and azimuth *(Az)* error statistics. Slant plane defined at *SCP COA*.
"""
_fields = ('Rg', 'Az', 'RgAz')
_required = _fields
_numeric_format = {key: '0.16G' for key in _fields}
# descriptors
Rg = FloatDescriptor(
'Rg', _required, strict=DEFAULT_STRICT,
docstring='Estimated range error standard deviation.') # type: float
Az = FloatDescriptor(
'Az', _required, strict=DEFAULT_STRICT,
docstring='Estimated azimuth error standard deviation.') # type: float
RgAz = FloatDescriptor(
'RgAz', _required, strict=DEFAULT_STRICT,
docstring='Estimated range and azimuth error correlation coefficient.') # type: float
def __init__(self, Rg=None, Az=None, RgAz=None, **kwargs):
"""
Parameters
----------
Rg : float
Az : float
RgAz : float
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Rg, self.Az, self.RgAz = Rg, Az, RgAz
super(CompositeSCPErrorType, self).__init__(**kwargs)
class TropoParametersType(Serializable):
"""
Parameters used to compute the propagation delay due to the troposphere.
"""
_fields = ('N0', 'RefHeight')
_required = _fields
_numeric_format = {'N0': FLOAT_FORMAT}
# descriptors
N0 = FloatDescriptor(
'N0',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Refractivity value of the troposphere for the imaged scene used '
'to form the product (dimensionless). Value at the IARP '
'location.') # type: float
RefHeight = StringEnumDescriptor(
'RefHeight', ('IARP', 'ZERO'),
_required,
strict=DEFAULT_STRICT,
docstring='Reference Height for the `N0` value.') # type: str
def __init__(self, N0=None, RefHeight=None, **kwargs):
"""
Parameters
----------
N0 : float
RefHeight : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.N0 = N0
self.RefHeight = RefHeight
super(TropoParametersType, self).__init__(**kwargs)
class YDirectionType(Serializable):
"""The Y direction of the collect"""
_fields = ('UVectECF', 'SampleSpacing', 'NumSamples', 'FirstSample')
_required = _fields
_numeric_format = {'SampleSpacing': FLOAT_FORMAT, }
# descriptors
UVectECF = UnitVectorDescriptor(
'UVectECF', XYZType, _required, strict=DEFAULT_STRICT,
docstring='The unit vector in the Y direction.') # type: XYZType
SampleSpacing = FloatDescriptor(
'SampleSpacing', _required, strict=DEFAULT_STRICT,
docstring='The collection sample spacing in the Y direction in meters.') # type: float
NumSamples = IntegerDescriptor(
'NumSamples', _required, strict=DEFAULT_STRICT,
docstring='The number of samples in the Y direction.') # type: int
FirstSample = IntegerDescriptor(
'FirstSample', _required, strict=DEFAULT_STRICT,
docstring='The first sample index.') # type: int
def __init__(self, UVectECF=None, SampleSpacing=None, NumSamples=None, FirstSample=None, **kwargs):
"""
Parameters
----------
UVectECF : XYZType|numpy.ndarray|list|tuple
SampleSpacing : float
NumSamples : int
FirstSample : int
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.UVectECF = UVectECF
self.SampleSpacing = SampleSpacing
self.NumSamples = NumSamples
self.FirstSample = FirstSample
super(YDirectionType, self).__init__(**kwargs)
class RcvChanProcType(Serializable):
"""The Received Processed Channels."""
_fields = ('NumChanProc', 'PRFScaleFactor', 'ChanIndices')
_required = ('NumChanProc', 'ChanIndices')
_collections_tags = {
'ChanIndices': {'array': False, 'child_tag': 'ChanIndex'}}
_numeric_format = {'PRFScaleFactor': FLOAT_FORMAT}
# descriptors
NumChanProc = IntegerDescriptor(
'NumChanProc', _required, strict=DEFAULT_STRICT,
docstring='Number of receive data channels processed to form the image.') # type: int
PRFScaleFactor = FloatDescriptor(
'PRFScaleFactor', _required, strict=DEFAULT_STRICT,
docstring='Factor indicating the ratio of the effective PRF to the actual PRF.') # type: float
ChanIndices = IntegerListDescriptor(
'ChanIndices', _collections_tags, _required, strict=DEFAULT_STRICT,
docstring='Index of a data channel that was processed.') # type: List[int]
def __init__(self, NumChanProc=None, PRFScaleFactor=None, ChanIndices=None, **kwargs):
"""
Parameters
----------
NumChanProc : int
PRFScaleFactor : float
ChanIndices : List[int]
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.NumChanProc = NumChanProc
self.PRFScaleFactor = PRFScaleFactor
self.ChanIndices = ChanIndices
super(RcvChanProcType, self).__init__(**kwargs)
class TOAExtendedType(Serializable):
"""
The time-of-arrival (TOA) extended swath information.
"""
_fields = ('TOAExtSaved', 'LFMEclipse')
_required = ('TOAExtSaved', )
_numeric_format = {'TOAExtSaved': FLOAT_FORMAT}
# descriptors
TOAExtSaved = FloatDescriptor(
'TOAExtSaved', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='TOA extended swath saved that includes both full and partially '
'eclipsed echoes.') # type: float
LFMEclipse = SerializableDescriptor(
'LFMEclipse', LFMEclipseType, _required, strict=DEFAULT_STRICT,
docstring='Parameters that describe the FX domain signal content for partially '
'eclipsed echoes when the collection is performed with a Linear '
'FM waveform.') # type: Union[None, LFMEclipseType]
def __init__(self, TOAExtSaved=None, LFMEclipse=None, **kwargs):
"""
Parameters
----------
TOAExtSaved : float
LFMEclipse : None|LFMEclipseType
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.TOAExtSaved = TOAExtSaved
self.LFMEclipse = LFMEclipse
super(TOAExtendedType, self).__init__(**kwargs)
class TimelineType(Serializable):
"""
Parameters that describe the collection times for the data contained in the product.
"""
_fields = ('CollectionStart', 'RcvCollectionStart', 'TxTime1', 'TxTime2')
_required = ('CollectionStart', 'TxTime1', 'TxTime2')
_numeric_format = {'TxTime1': FLOAT_FORMAT, 'TxTime2': FLOAT_FORMAT}
# descriptors
CollectionStart = DateTimeDescriptor(
'CollectionStart',
_required,
strict=DEFAULT_STRICT,
numpy_datetime_units='us',
docstring=
'Collection Start date and time (UTC). Time reference used for times '
'measured from collection start (i.e. slow time t = 0). For bistatic '
'collections, the time is the transmit platform collection '
'start time. The default display precision is microseconds, but this '
'does not that accuracy in value.') # type: numpy.datetime64
RcvCollectionStart = DateTimeDescriptor(
'RcvCollectionStart',
_required,
strict=DEFAULT_STRICT,
numpy_datetime_units='us',
docstring='Receive only platform collection date and start time.'
) # type: numpy.datetime64
TxTime1 = FloatDescriptor(
'TxTime1',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Earliest TxTime value for any signal vector in the product. '
'Time relative to Collection Start in seconds.') # type: float
TxTime2 = FloatDescriptor(
'TxTime2',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Latest TxTime value for any signal vector in the product. '
'Time relative to Collection Start in seconds.') # type: float
def __init__(self,
CollectionStart=None,
RcvCollectionStart=None,
TxTime1=None,
TxTime2=None,
**kwargs):
"""
Parameters
----------
CollectionStart : numpy.datetime64|datetime|date|str
RcvCollectionStart : None|numpy.datetime64|datetime|date|str
TxTime1 : float
TxTime2 : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.CollectionStart = CollectionStart
self.RcvCollectionStart = RcvCollectionStart
self.TxTime1 = TxTime1
self.TxTime2 = TxTime2
super(TimelineType, self).__init__(**kwargs)
class INCAType(Serializable):
"""Parameters for Imaging Near Closest Approach (INCA) image description."""
_fields = ('TimeCAPoly', 'R_CA_SCP', 'FreqZero', 'DRateSFPoly',
'DopCentroidPoly', 'DopCentroidCOA')
_required = ('TimeCAPoly', 'R_CA_SCP', 'FreqZero', 'DRateSFPoly')
_numeric_format = {'R_CA_SCP': '0.17E', 'FreqZero': '0.17E'}
# descriptors
TimeCAPoly = SerializableDescriptor(
'TimeCAPoly',
Poly1DType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Polynomial function that yields *Time of Closest Approach* as function of '
'image column *(azimuth)* coordinate in meters. Time relative to '
'collection start in seconds.') # type: Poly1DType
R_CA_SCP = FloatDescriptor(
'R_CA_SCP',
_required,
strict=DEFAULT_STRICT,
docstring=
'*Range at Closest Approach (R_CA)* for the *Scene Center Point (SCP)* in meters.'
) # type: float
FreqZero = FloatDescriptor(
'FreqZero',
_required,
strict=DEFAULT_STRICT,
docstring=r'*RF frequency* :\math:`(f_0)` in Hz used for computing '
r'Doppler Centroid values. Typical :math:`f_0` '
r'set equal to center transmit frequency.') # type: float
DRateSFPoly = SerializableDescriptor(
'DRateSFPoly',
Poly2DType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Polynomial function that yields *Doppler Rate scale factor (DRSF)* '
'as a function of image location. Yields `DRSF` as a function of image '
'range coordinate ``(variable 1)`` and azimuth coordinate ``(variable 2)``. '
'Used to compute Doppler Rate at closest approach.'
) # type: Poly2DType
DopCentroidPoly = SerializableDescriptor(
'DopCentroidPoly',
Poly2DType,
_required,
strict=DEFAULT_STRICT,
docstring='Polynomial function that yields Doppler Centroid value as a '
'function of image location *(fdop_DC)*. The *fdop_DC* is the '
'Doppler frequency at the peak signal response. The polynomial is a function '
'of image range coordinate ``(variable 1)`` and azimuth coordinate ``(variable 2)``. '
'*Note: Only used for Stripmap and Dynamic Stripmap collections.*'
) # type: Poly2DType
DopCentroidCOA = BooleanDescriptor(
'DopCentroidCOA',
_required,
strict=DEFAULT_STRICT,
docstring=
"""Flag indicating that the COA is at the peak signal :math`fdop_COA = fdop_DC`.
* `True` - if Pixel COA at peak signal for all pixels.
* `False` otherwise.
*Note:* Only used for Stripmap and Dynamic Stripmap.""") # type: bool
def __init__(self,
TimeCAPoly=None,
R_CA_SCP=None,
FreqZero=None,
DRateSFPoly=None,
DopCentroidPoly=None,
DopCentroidCOA=None,
**kwargs):
"""
Parameters
----------
TimeCAPoly : Poly1DType|numpy.ndarray|list|tuple
R_CA_SCP : float
FreqZero : float
DRateSFPoly : Poly2DType|numpy.ndarray|list|tuple
DopCentroidPoly : Poly2DType|numpy.ndarray|list|tuple
DopCentroidCOA : bool
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.TimeCAPoly = TimeCAPoly
self.R_CA_SCP = R_CA_SCP
self.FreqZero = FreqZero
self.DRateSFPoly = DRateSFPoly
self.DopCentroidPoly = DopCentroidPoly
self.DopCentroidCOA = DopCentroidCOA
super(INCAType, self).__init__(**kwargs)
def _apply_reference_frequency(self, reference_frequency):
if self.FreqZero is not None:
self.FreqZero += reference_frequency
class IonoErrorType(Serializable):
"""
Ionosphere delay error statistics.
"""
_fields = ('IonoRangeVertical', 'IonoRangeRateVertical', 'IonoRgRgRateCC',
'IonoRangeVertDecorr')
_required = ('IonoRangeVertical', )
_numeric_format = {
'IonoRangeVertical': '0.16G',
'IonoRangeRateVertical': '0.16G',
'IonoRgRgRateCC': '0.16G'
}
# descriptors
IonoRangeVertical = FloatDescriptor(
'IonoRangeVertical',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Ionosphere two-way delay error for normal incidence standard deviation. '
r'Expressed as a range error. :math:`(\Delta R) = (\Delta T) \cdot (c/2)`.'
) # type: float
IonoRangeRateVertical = FloatDescriptor(
'IonoRangeRateVertical',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Ionosphere two-way delay rate of change error for normal incidence standard deviation. '
r'Expressed as a range rate error. :math:`\dot{R} = \Delta \dot{TD_Iono} \times c/2`.'
) # type: float
IonoRgRgRateCC = FloatDescriptor(
'IonoRgRgRateCC',
_required,
strict=DEFAULT_STRICT,
bounds=(-1, 1),
docstring=
'Ionosphere range error and range rate error correlation coefficient.'
) # type: float
IonoRangeVertDecorr = SerializableDescriptor(
'IonoRangeVertDecorr',
ErrorDecorrFuncType,
_required,
strict=DEFAULT_STRICT,
docstring='Ionosphere range error decorrelation function.'
) # type: ErrorDecorrFuncType
def __init__(self,
IonoRangeVertical=None,
IonoRangeRateVertical=None,
IonoRgRgRateCC=None,
IonoRangeVertDecorr=None,
**kwargs):
"""
Parameters
----------
IonoRangeVertical : float
IonoRangeRateVertical : None|float
IonoRgRgRateCC : None|float
IonoRangeVertDecorr : None|ErrorDecorrFuncType
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.IonoRangeVertical = IonoRangeVertical
self.IonoRangeRateVertical = IonoRangeRateVertical
self.IonoRgRgRateCC = IonoRgRgRateCC
self.IonoRangeVertDecorr = IonoRangeVertDecorr
super(IonoErrorType, self).__init__(**kwargs)
class LatLonEleType(Serializable, Arrayable):
"""A three-dimensional geographic point in WGS-84 coordinates."""
_fields = ('Lat', 'Lon', 'Ele')
_required = _fields
_numeric_format = {'Lat': '0.16G', 'Lon': '0.16G', 'Ele': '0.16G'}
# descriptors
Lat = FloatDescriptor(
'Lat',
_required,
strict=True,
docstring='The latitude attribute. Assumed to be WGS-84 coordinates.'
) # type: float
Lon = FloatDescriptor(
'Lon',
_required,
strict=True,
docstring='The longitude attribute. Assumed to be WGS-84 coordinates.'
) # type: float
Ele = FloatDescriptor(
'Ele',
_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, Ele=None, **kwargs):
"""
Parameters
----------
Lat : float
Lon : float
Ele : float
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Lat = Lat
self.Lon = Lon
self.Ele = Ele
super(LatLonEleType, self).__init__(Lat=Lat, Lon=Lon, **kwargs)
def get_array(self, dtype=numpy.float64):
"""
Gets an array representation of the data.
Parameters
----------
dtype : str|numpy.dtype|numpy.number
data type of the return
Returns
-------
numpy.ndarray
data array with appropriate entry order
"""
return numpy.array([self.Lat, self.Lon, self.Ele], dtype=dtype)
@classmethod
def from_array(cls, array):
"""
Create from an array type entry.
Parameters
----------
array: numpy.ndarray|list|tuple
assumed [Lat, Lon, Ele]
Returns
-------
LatLonEleType
"""
if array is None:
return None
if isinstance(array, (numpy.ndarray, list, tuple)):
if len(array) < 3:
raise ValueError(
'Expected array to be of length 3, and received {}'.format(
array))
return cls(Lat=array[0], Lon=array[1], Ele=array[2])
raise ValueError(
'Expected array to be numpy.ndarray, list, or tuple, got {}'.
format(type(array)))
class RowColDoubleType(Serializable, Arrayable):
_fields = ('Row', 'Col')
_required = _fields
_numeric_format = {key: '0.16G' for key in _fields}
# Descriptors
Row = FloatDescriptor('Row',
_required,
strict=True,
docstring='The Row attribute.') # type: float
Col = FloatDescriptor('Col',
_required,
strict=True,
docstring='The Column attribute.') # type: float
def __init__(self, Row=None, Col=None, **kwargs):
"""
Parameters
----------
Row : float
Col : float
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Row, self.Col = Row, Col
super(RowColDoubleType, self).__init__(**kwargs)
def get_array(self, dtype='float64'):
"""
Gets an array representation of the class instance.
Parameters
----------
dtype : str|numpy.dtype|numpy.number
numpy data type of the return
Returns
-------
numpy.ndarray
array of the form [Row, Col]
"""
return numpy.array([self.Row, self.Col], dtype=dtype)
@classmethod
def from_array(cls, array):
"""
Create from an array type entry.
Parameters
----------
array: numpy.ndarray|list|tuple
assumed [Row, Col]
Returns
-------
RowColDoubleType
"""
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(Row=array[0], Col=array[1])
raise ValueError(
'Expected array to be numpy.ndarray, list, or tuple, got {}'.
format(type(array)))
class AntPatternType(Serializable):
"""
Parameter set that defines each one-way Antenna Pattern.
"""
_fields = ('Identifier', 'FreqZero', 'EBFreqShift', 'MLFreqDilation',
'GainZero', 'GainBSPoly', 'ArrayGPId', 'ElementGPId')
_required = ('Identifier', 'FreqZero', 'EBFreqShift', 'MLFreqDilation',
'ArrayGPId', 'ElementGPId')
_numeric_format = {'FreqZero': FLOAT_FORMAT, 'GainZero': FLOAT_FORMAT}
# descriptors
Identifier = StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies this Antenna Pattern'
) # type: str
FreqZero = FloatDescriptor(
'FreqZero',
_required,
strict=DEFAULT_STRICT,
docstring=
'The reference frequency value for which the patterns are computed.'
) # type: float
EBFreqShift = BooleanDescriptor(
'EBFreqShift',
_required,
strict=DEFAULT_STRICT,
docstring=
"Parameter indicating whether the electronic boresight shifts with "
"frequency.") # type: bool
MLFreqDilation = BooleanDescriptor(
'MLFreqDilation',
_required,
strict=DEFAULT_STRICT,
docstring="Parameter indicating the mainlobe (ML) width changes with "
"frequency.") # type: bool
GainZero = FloatDescriptor(
'GainZero',
_required,
strict=DEFAULT_STRICT,
docstring='The reference antenna gain at zero steering angle at the '
'reference frequency, measured in dB.') # type: float
GainBSPoly = SerializableDescriptor(
'GainBSPoly',
Poly1DType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Gain polynomial *(in dB)* as a function of frequency for boresight *(BS)* '
'at :math:`DCX=0, DCY=0`. '
'Frequency ratio :math:`(f-f0)/f0` is the input variable, and the constant '
'coefficient is always `0.0`.') # type: Poly1DType
ArrayGPId = StringDescriptor(
'ArrayGPId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the array '
'at ref frequency.') # type: str
ElementGPId = StringDescriptor(
'ElementGPId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the element '
'at ref frequency.') # type: str
def __init__(self,
Identifier=None,
FreqZero=None,
EBFreqShift=None,
MLFreqDilation=None,
GainZero=None,
GainBSPoly=None,
ArrayGPId=None,
ElementGPId=None,
**kwargs):
"""
Parameters
----------
Identifier : str
FreqZero : float
EBFreqShift : bool
MLFreqDilation : bool
GainZero : None|float
GainBSPoly : None|Poly1DType
ArrayGPId : str
ElementGPId : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Identifier = Identifier
self.FreqZero = FreqZero
self.EBFreqShift = EBFreqShift
self.MLFreqDilation = MLFreqDilation
self.GainZero = GainZero
self.GainBSPoly = GainBSPoly
self.ArrayGPId = ArrayGPId
self.ElementGPId = ElementGPId
super(AntPatternType, self).__init__(**kwargs)
