spacedatastandards.org 1.73.0__py3-none-any.whl

RFO/RFO.py

@@ -0,0 +1,1361 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# RF Observation
+class RFO(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RFO()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRFO(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def RFOBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x52\x46\x4F", size_prefixed=size_prefixed)
+
+    # RFO
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # RFO
+    def ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def OB_TIME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def ID_SENSOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def SAT_NO(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # RFO
+    def TASK_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def TRANSACTION_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def TRACK_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def ORIG_OBJECT_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def ORIG_SENSOR_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def UCT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # RFO
+    def TRANSPONDER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def AZIMUTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def AZIMUTH_UNC(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def AZIMUTH_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def ELEVATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def ELEVATION_UNC(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def ELEVATION_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RANGE_UNC(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RANGE_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RANGE_RATE_UNC(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def TRACK_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SENLAT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SENLON(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SENALT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def ELNOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def FREQUENCY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def NOMINAL_FREQUENCY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def START_FREQUENCY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def END_FREQUENCY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RELATIVE_CARRIER_POWER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SPECTRUM_ANALYZER_POWER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RELATIVE_NOISE_FLOOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def REFERENCE_LEVEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def PGRI(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def CONFIDENCE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def INCOMING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # RFO
+    def SWITCH_POINT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # RFO
+    def BAUD_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SNR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def NOMINAL_SNR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def POLARITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def POLARITY_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def CHANNEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # RFO
+    def POWER_OVER_NOISE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def NOMINAL_POWER_OVER_NOISE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def BANDWIDTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def NOMINAL_BANDWIDTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def RESOLUTION_BANDWIDTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def VIDEO_BANDWIDTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def EIRP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def NOMINAL_EIRP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def MIN_PSD(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def MAX_PSD(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def FREQUENCY_SHIFT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def PEAK(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # RFO
+    def ANTENNA_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def DETECTION_STATUS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def COLLECTION_MODE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def RAW_FILE_URI(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def TAGS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # RFO
+    def TAGSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # RFO
+    def TAGSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
+        return o == 0
+
+    # RFO
+    def NOISE_PWR_DENSITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(128))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def CARRIER_STANDARD(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(130))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def MODULATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(132))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def INNER_CODING_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(134))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # RFO
+    def OUTER_CODING_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(136))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # RFO
+    def TRANSMIT_FILTER_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(138))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def TRANSMIT_FILTER_ROLL_OFF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(140))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def SYMBOL_TO_NOISE_RATIO(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(142))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def BIT_ERROR_RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RFO
+    def ON_ORBIT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(146))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def DESCRIPTOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(148))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RFO
+    def URL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(150))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def RFOStart(builder):
+    builder.StartObject(74)
+
+def Start(builder):
+    RFOStart(builder)
+
+def RFOAddID(builder, ID):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ID), 0)
+
+def AddID(builder, ID):
+    RFOAddID(builder, ID)
+
+def RFOAddOB_TIME(builder, OB_TIME):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(OB_TIME), 0)
+
+def AddOB_TIME(builder, OB_TIME):
+    RFOAddOB_TIME(builder, OB_TIME)
+
+def RFOAddID_SENSOR(builder, ID_SENSOR):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(ID_SENSOR), 0)
+
+def AddID_SENSOR(builder, ID_SENSOR):
+    RFOAddID_SENSOR(builder, ID_SENSOR)
+
+def RFOAddTYPE(builder, TYPE):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(TYPE), 0)
+
+def AddTYPE(builder, TYPE):
+    RFOAddTYPE(builder, TYPE)
+
+def RFOAddSAT_NO(builder, SAT_NO):
+    builder.PrependInt32Slot(4, SAT_NO, 0)
+
+def AddSAT_NO(builder, SAT_NO):
+    RFOAddSAT_NO(builder, SAT_NO)
+
+def RFOAddTASK_ID(builder, TASK_ID):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(TASK_ID), 0)
+
+def AddTASK_ID(builder, TASK_ID):
+    RFOAddTASK_ID(builder, TASK_ID)
+
+def RFOAddTRANSACTION_ID(builder, TRANSACTION_ID):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSACTION_ID), 0)
+
+def AddTRANSACTION_ID(builder, TRANSACTION_ID):
+    RFOAddTRANSACTION_ID(builder, TRANSACTION_ID)
+
+def RFOAddTRACK_ID(builder, TRACK_ID):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(TRACK_ID), 0)
+
+def AddTRACK_ID(builder, TRACK_ID):
+    RFOAddTRACK_ID(builder, TRACK_ID)
+
+def RFOAddORIG_OBJECT_ID(builder, ORIG_OBJECT_ID):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(ORIG_OBJECT_ID), 0)
+
+def AddORIG_OBJECT_ID(builder, ORIG_OBJECT_ID):
+    RFOAddORIG_OBJECT_ID(builder, ORIG_OBJECT_ID)
+
+def RFOAddORIG_SENSOR_ID(builder, ORIG_SENSOR_ID):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(ORIG_SENSOR_ID), 0)
+
+def AddORIG_SENSOR_ID(builder, ORIG_SENSOR_ID):
+    RFOAddORIG_SENSOR_ID(builder, ORIG_SENSOR_ID)
+
+def RFOAddUCT(builder, UCT):
+    builder.PrependBoolSlot(10, UCT, 0)
+
+def AddUCT(builder, UCT):
+    RFOAddUCT(builder, UCT)
+
+def RFOAddTRANSPONDER(builder, TRANSPONDER):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSPONDER), 0)
+
+def AddTRANSPONDER(builder, TRANSPONDER):
+    RFOAddTRANSPONDER(builder, TRANSPONDER)
+
+def RFOAddAZIMUTH(builder, AZIMUTH):
+    builder.PrependFloat64Slot(12, AZIMUTH, 0.0)
+
+def AddAZIMUTH(builder, AZIMUTH):
+    RFOAddAZIMUTH(builder, AZIMUTH)
+
+def RFOAddAZIMUTH_UNC(builder, AZIMUTH_UNC):
+    builder.PrependFloat64Slot(13, AZIMUTH_UNC, 0.0)
+
+def AddAZIMUTH_UNC(builder, AZIMUTH_UNC):
+    RFOAddAZIMUTH_UNC(builder, AZIMUTH_UNC)
+
+def RFOAddAZIMUTH_RATE(builder, AZIMUTH_RATE):
+    builder.PrependFloat64Slot(14, AZIMUTH_RATE, 0.0)
+
+def AddAZIMUTH_RATE(builder, AZIMUTH_RATE):
+    RFOAddAZIMUTH_RATE(builder, AZIMUTH_RATE)
+
+def RFOAddELEVATION(builder, ELEVATION):
+    builder.PrependFloat64Slot(15, ELEVATION, 0.0)
+
+def AddELEVATION(builder, ELEVATION):
+    RFOAddELEVATION(builder, ELEVATION)
+
+def RFOAddELEVATION_UNC(builder, ELEVATION_UNC):
+    builder.PrependFloat64Slot(16, ELEVATION_UNC, 0.0)
+
+def AddELEVATION_UNC(builder, ELEVATION_UNC):
+    RFOAddELEVATION_UNC(builder, ELEVATION_UNC)
+
+def RFOAddELEVATION_RATE(builder, ELEVATION_RATE):
+    builder.PrependFloat64Slot(17, ELEVATION_RATE, 0.0)
+
+def AddELEVATION_RATE(builder, ELEVATION_RATE):
+    RFOAddELEVATION_RATE(builder, ELEVATION_RATE)
+
+def RFOAddRANGE(builder, RANGE):
+    builder.PrependFloat64Slot(18, RANGE, 0.0)
+
+def AddRANGE(builder, RANGE):
+    RFOAddRANGE(builder, RANGE)
+
+def RFOAddRANGE_UNC(builder, RANGE_UNC):
+    builder.PrependFloat64Slot(19, RANGE_UNC, 0.0)
+
+def AddRANGE_UNC(builder, RANGE_UNC):
+    RFOAddRANGE_UNC(builder, RANGE_UNC)
+
+def RFOAddRANGE_RATE(builder, RANGE_RATE):
+    builder.PrependFloat64Slot(20, RANGE_RATE, 0.0)
+
+def AddRANGE_RATE(builder, RANGE_RATE):
+    RFOAddRANGE_RATE(builder, RANGE_RATE)
+
+def RFOAddRANGE_RATE_UNC(builder, RANGE_RATE_UNC):
+    builder.PrependFloat64Slot(21, RANGE_RATE_UNC, 0.0)
+
+def AddRANGE_RATE_UNC(builder, RANGE_RATE_UNC):
+    RFOAddRANGE_RATE_UNC(builder, RANGE_RATE_UNC)
+
+def RFOAddTRACK_RANGE(builder, TRACK_RANGE):
+    builder.PrependFloat64Slot(22, TRACK_RANGE, 0.0)
+
+def AddTRACK_RANGE(builder, TRACK_RANGE):
+    RFOAddTRACK_RANGE(builder, TRACK_RANGE)
+
+def RFOAddSENLAT(builder, SENLAT):
+    builder.PrependFloat64Slot(23, SENLAT, 0.0)
+
+def AddSENLAT(builder, SENLAT):
+    RFOAddSENLAT(builder, SENLAT)
+
+def RFOAddSENLON(builder, SENLON):
+    builder.PrependFloat64Slot(24, SENLON, 0.0)
+
+def AddSENLON(builder, SENLON):
+    RFOAddSENLON(builder, SENLON)
+
+def RFOAddSENALT(builder, SENALT):
+    builder.PrependFloat64Slot(25, SENALT, 0.0)
+
+def AddSENALT(builder, SENALT):
+    RFOAddSENALT(builder, SENALT)
+
+def RFOAddELNOT(builder, ELNOT):
+    builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(ELNOT), 0)
+
+def AddELNOT(builder, ELNOT):
+    RFOAddELNOT(builder, ELNOT)
+
+def RFOAddFREQUENCY(builder, FREQUENCY):
+    builder.PrependFloat64Slot(27, FREQUENCY, 0.0)
+
+def AddFREQUENCY(builder, FREQUENCY):
+    RFOAddFREQUENCY(builder, FREQUENCY)
+
+def RFOAddNOMINAL_FREQUENCY(builder, NOMINAL_FREQUENCY):
+    builder.PrependFloat64Slot(28, NOMINAL_FREQUENCY, 0.0)
+
+def AddNOMINAL_FREQUENCY(builder, NOMINAL_FREQUENCY):
+    RFOAddNOMINAL_FREQUENCY(builder, NOMINAL_FREQUENCY)
+
+def RFOAddSTART_FREQUENCY(builder, START_FREQUENCY):
+    builder.PrependFloat64Slot(29, START_FREQUENCY, 0.0)
+
+def AddSTART_FREQUENCY(builder, START_FREQUENCY):
+    RFOAddSTART_FREQUENCY(builder, START_FREQUENCY)
+
+def RFOAddEND_FREQUENCY(builder, END_FREQUENCY):
+    builder.PrependFloat64Slot(30, END_FREQUENCY, 0.0)
+
+def AddEND_FREQUENCY(builder, END_FREQUENCY):
+    RFOAddEND_FREQUENCY(builder, END_FREQUENCY)
+
+def RFOAddRELATIVE_CARRIER_POWER(builder, RELATIVE_CARRIER_POWER):
+    builder.PrependFloat64Slot(31, RELATIVE_CARRIER_POWER, 0.0)
+
+def AddRELATIVE_CARRIER_POWER(builder, RELATIVE_CARRIER_POWER):
+    RFOAddRELATIVE_CARRIER_POWER(builder, RELATIVE_CARRIER_POWER)
+
+def RFOAddSPECTRUM_ANALYZER_POWER(builder, SPECTRUM_ANALYZER_POWER):
+    builder.PrependFloat64Slot(32, SPECTRUM_ANALYZER_POWER, 0.0)
+
+def AddSPECTRUM_ANALYZER_POWER(builder, SPECTRUM_ANALYZER_POWER):
+    RFOAddSPECTRUM_ANALYZER_POWER(builder, SPECTRUM_ANALYZER_POWER)
+
+def RFOAddRELATIVE_NOISE_FLOOR(builder, RELATIVE_NOISE_FLOOR):
+    builder.PrependFloat64Slot(33, RELATIVE_NOISE_FLOOR, 0.0)
+
+def AddRELATIVE_NOISE_FLOOR(builder, RELATIVE_NOISE_FLOOR):
+    RFOAddRELATIVE_NOISE_FLOOR(builder, RELATIVE_NOISE_FLOOR)
+
+def RFOAddREFERENCE_LEVEL(builder, REFERENCE_LEVEL):
+    builder.PrependFloat64Slot(34, REFERENCE_LEVEL, 0.0)
+
+def AddREFERENCE_LEVEL(builder, REFERENCE_LEVEL):
+    RFOAddREFERENCE_LEVEL(builder, REFERENCE_LEVEL)
+
+def RFOAddPGRI(builder, PGRI):
+    builder.PrependFloat64Slot(35, PGRI, 0.0)
+
+def AddPGRI(builder, PGRI):
+    RFOAddPGRI(builder, PGRI)
+
+def RFOAddCONFIDENCE(builder, CONFIDENCE):
+    builder.PrependFloat64Slot(36, CONFIDENCE, 0.0)
+
+def AddCONFIDENCE(builder, CONFIDENCE):
+    RFOAddCONFIDENCE(builder, CONFIDENCE)
+
+def RFOAddINCOMING(builder, INCOMING):
+    builder.PrependBoolSlot(37, INCOMING, 0)
+
+def AddINCOMING(builder, INCOMING):
+    RFOAddINCOMING(builder, INCOMING)
+
+def RFOAddSWITCH_POINT(builder, SWITCH_POINT):
+    builder.PrependInt32Slot(38, SWITCH_POINT, 0)
+
+def AddSWITCH_POINT(builder, SWITCH_POINT):
+    RFOAddSWITCH_POINT(builder, SWITCH_POINT)
+
+def RFOAddBAUD_RATE(builder, BAUD_RATE):
+    builder.PrependFloat64Slot(39, BAUD_RATE, 0.0)
+
+def AddBAUD_RATE(builder, BAUD_RATE):
+    RFOAddBAUD_RATE(builder, BAUD_RATE)
+
+def RFOAddSNR(builder, SNR):
+    builder.PrependFloat64Slot(40, SNR, 0.0)
+
+def AddSNR(builder, SNR):
+    RFOAddSNR(builder, SNR)
+
+def RFOAddNOMINAL_SNR(builder, NOMINAL_SNR):
+    builder.PrependFloat64Slot(41, NOMINAL_SNR, 0.0)
+
+def AddNOMINAL_SNR(builder, NOMINAL_SNR):
+    RFOAddNOMINAL_SNR(builder, NOMINAL_SNR)
+
+def RFOAddPOLARITY(builder, POLARITY):
+    builder.PrependFloat64Slot(42, POLARITY, 0.0)
+
+def AddPOLARITY(builder, POLARITY):
+    RFOAddPOLARITY(builder, POLARITY)
+
+def RFOAddPOLARITY_TYPE(builder, POLARITY_TYPE):
+    builder.PrependUOffsetTRelativeSlot(43, flatbuffers.number_types.UOffsetTFlags.py_type(POLARITY_TYPE), 0)
+
+def AddPOLARITY_TYPE(builder, POLARITY_TYPE):
+    RFOAddPOLARITY_TYPE(builder, POLARITY_TYPE)
+
+def RFOAddCHANNEL(builder, CHANNEL):
+    builder.PrependInt32Slot(44, CHANNEL, 0)
+
+def AddCHANNEL(builder, CHANNEL):
+    RFOAddCHANNEL(builder, CHANNEL)
+
+def RFOAddPOWER_OVER_NOISE(builder, POWER_OVER_NOISE):
+    builder.PrependFloat64Slot(45, POWER_OVER_NOISE, 0.0)
+
+def AddPOWER_OVER_NOISE(builder, POWER_OVER_NOISE):
+    RFOAddPOWER_OVER_NOISE(builder, POWER_OVER_NOISE)
+
+def RFOAddNOMINAL_POWER_OVER_NOISE(builder, NOMINAL_POWER_OVER_NOISE):
+    builder.PrependFloat64Slot(46, NOMINAL_POWER_OVER_NOISE, 0.0)
+
+def AddNOMINAL_POWER_OVER_NOISE(builder, NOMINAL_POWER_OVER_NOISE):
+    RFOAddNOMINAL_POWER_OVER_NOISE(builder, NOMINAL_POWER_OVER_NOISE)
+
+def RFOAddBANDWIDTH(builder, BANDWIDTH):
+    builder.PrependFloat64Slot(47, BANDWIDTH, 0.0)
+
+def AddBANDWIDTH(builder, BANDWIDTH):
+    RFOAddBANDWIDTH(builder, BANDWIDTH)
+
+def RFOAddNOMINAL_BANDWIDTH(builder, NOMINAL_BANDWIDTH):
+    builder.PrependFloat64Slot(48, NOMINAL_BANDWIDTH, 0.0)
+
+def AddNOMINAL_BANDWIDTH(builder, NOMINAL_BANDWIDTH):
+    RFOAddNOMINAL_BANDWIDTH(builder, NOMINAL_BANDWIDTH)
+
+def RFOAddRESOLUTION_BANDWIDTH(builder, RESOLUTION_BANDWIDTH):
+    builder.PrependFloat64Slot(49, RESOLUTION_BANDWIDTH, 0.0)
+
+def AddRESOLUTION_BANDWIDTH(builder, RESOLUTION_BANDWIDTH):
+    RFOAddRESOLUTION_BANDWIDTH(builder, RESOLUTION_BANDWIDTH)
+
+def RFOAddVIDEO_BANDWIDTH(builder, VIDEO_BANDWIDTH):
+    builder.PrependFloat64Slot(50, VIDEO_BANDWIDTH, 0.0)
+
+def AddVIDEO_BANDWIDTH(builder, VIDEO_BANDWIDTH):
+    RFOAddVIDEO_BANDWIDTH(builder, VIDEO_BANDWIDTH)
+
+def RFOAddEIRP(builder, EIRP):
+    builder.PrependFloat64Slot(51, EIRP, 0.0)
+
+def AddEIRP(builder, EIRP):
+    RFOAddEIRP(builder, EIRP)
+
+def RFOAddNOMINAL_EIRP(builder, NOMINAL_EIRP):
+    builder.PrependFloat64Slot(52, NOMINAL_EIRP, 0.0)
+
+def AddNOMINAL_EIRP(builder, NOMINAL_EIRP):
+    RFOAddNOMINAL_EIRP(builder, NOMINAL_EIRP)
+
+def RFOAddMIN_PSD(builder, MIN_PSD):
+    builder.PrependFloat64Slot(53, MIN_PSD, 0.0)
+
+def AddMIN_PSD(builder, MIN_PSD):
+    RFOAddMIN_PSD(builder, MIN_PSD)
+
+def RFOAddMAX_PSD(builder, MAX_PSD):
+    builder.PrependFloat64Slot(54, MAX_PSD, 0.0)
+
+def AddMAX_PSD(builder, MAX_PSD):
+    RFOAddMAX_PSD(builder, MAX_PSD)
+
+def RFOAddFREQUENCY_SHIFT(builder, FREQUENCY_SHIFT):
+    builder.PrependFloat64Slot(55, FREQUENCY_SHIFT, 0.0)
+
+def AddFREQUENCY_SHIFT(builder, FREQUENCY_SHIFT):
+    RFOAddFREQUENCY_SHIFT(builder, FREQUENCY_SHIFT)
+
+def RFOAddPEAK(builder, PEAK):
+    builder.PrependBoolSlot(56, PEAK, 0)
+
+def AddPEAK(builder, PEAK):
+    RFOAddPEAK(builder, PEAK)
+
+def RFOAddANTENNA_NAME(builder, ANTENNA_NAME):
+    builder.PrependUOffsetTRelativeSlot(57, flatbuffers.number_types.UOffsetTFlags.py_type(ANTENNA_NAME), 0)
+
+def AddANTENNA_NAME(builder, ANTENNA_NAME):
+    RFOAddANTENNA_NAME(builder, ANTENNA_NAME)
+
+def RFOAddDETECTION_STATUS(builder, DETECTION_STATUS):
+    builder.PrependUOffsetTRelativeSlot(58, flatbuffers.number_types.UOffsetTFlags.py_type(DETECTION_STATUS), 0)
+
+def AddDETECTION_STATUS(builder, DETECTION_STATUS):
+    RFOAddDETECTION_STATUS(builder, DETECTION_STATUS)
+
+def RFOAddCOLLECTION_MODE(builder, COLLECTION_MODE):
+    builder.PrependUOffsetTRelativeSlot(59, flatbuffers.number_types.UOffsetTFlags.py_type(COLLECTION_MODE), 0)
+
+def AddCOLLECTION_MODE(builder, COLLECTION_MODE):
+    RFOAddCOLLECTION_MODE(builder, COLLECTION_MODE)
+
+def RFOAddRAW_FILE_URI(builder, RAW_FILE_URI):
+    builder.PrependUOffsetTRelativeSlot(60, flatbuffers.number_types.UOffsetTFlags.py_type(RAW_FILE_URI), 0)
+
+def AddRAW_FILE_URI(builder, RAW_FILE_URI):
+    RFOAddRAW_FILE_URI(builder, RAW_FILE_URI)
+
+def RFOAddTAGS(builder, TAGS):
+    builder.PrependUOffsetTRelativeSlot(61, flatbuffers.number_types.UOffsetTFlags.py_type(TAGS), 0)
+
+def AddTAGS(builder, TAGS):
+    RFOAddTAGS(builder, TAGS)
+
+def RFOStartTAGSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartTAGSVector(builder, numElems):
+    return RFOStartTAGSVector(builder, numElems)
+
+def RFOAddNOISE_PWR_DENSITY(builder, NOISE_PWR_DENSITY):
+    builder.PrependFloat64Slot(62, NOISE_PWR_DENSITY, 0.0)
+
+def AddNOISE_PWR_DENSITY(builder, NOISE_PWR_DENSITY):
+    RFOAddNOISE_PWR_DENSITY(builder, NOISE_PWR_DENSITY)
+
+def RFOAddCARRIER_STANDARD(builder, CARRIER_STANDARD):
+    builder.PrependUOffsetTRelativeSlot(63, flatbuffers.number_types.UOffsetTFlags.py_type(CARRIER_STANDARD), 0)
+
+def AddCARRIER_STANDARD(builder, CARRIER_STANDARD):
+    RFOAddCARRIER_STANDARD(builder, CARRIER_STANDARD)
+
+def RFOAddMODULATION(builder, MODULATION):
+    builder.PrependUOffsetTRelativeSlot(64, flatbuffers.number_types.UOffsetTFlags.py_type(MODULATION), 0)
+
+def AddMODULATION(builder, MODULATION):
+    RFOAddMODULATION(builder, MODULATION)
+
+def RFOAddINNER_CODING_RATE(builder, INNER_CODING_RATE):
+    builder.PrependInt32Slot(65, INNER_CODING_RATE, 0)
+
+def AddINNER_CODING_RATE(builder, INNER_CODING_RATE):
+    RFOAddINNER_CODING_RATE(builder, INNER_CODING_RATE)
+
+def RFOAddOUTER_CODING_RATE(builder, OUTER_CODING_RATE):
+    builder.PrependInt32Slot(66, OUTER_CODING_RATE, 0)
+
+def AddOUTER_CODING_RATE(builder, OUTER_CODING_RATE):
+    RFOAddOUTER_CODING_RATE(builder, OUTER_CODING_RATE)
+
+def RFOAddTRANSMIT_FILTER_TYPE(builder, TRANSMIT_FILTER_TYPE):
+    builder.PrependUOffsetTRelativeSlot(67, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSMIT_FILTER_TYPE), 0)
+
+def AddTRANSMIT_FILTER_TYPE(builder, TRANSMIT_FILTER_TYPE):
+    RFOAddTRANSMIT_FILTER_TYPE(builder, TRANSMIT_FILTER_TYPE)
+
+def RFOAddTRANSMIT_FILTER_ROLL_OFF(builder, TRANSMIT_FILTER_ROLL_OFF):
+    builder.PrependFloat64Slot(68, TRANSMIT_FILTER_ROLL_OFF, 0.0)
+
+def AddTRANSMIT_FILTER_ROLL_OFF(builder, TRANSMIT_FILTER_ROLL_OFF):
+    RFOAddTRANSMIT_FILTER_ROLL_OFF(builder, TRANSMIT_FILTER_ROLL_OFF)
+
+def RFOAddSYMBOL_TO_NOISE_RATIO(builder, SYMBOL_TO_NOISE_RATIO):
+    builder.PrependFloat64Slot(69, SYMBOL_TO_NOISE_RATIO, 0.0)
+
+def AddSYMBOL_TO_NOISE_RATIO(builder, SYMBOL_TO_NOISE_RATIO):
+    RFOAddSYMBOL_TO_NOISE_RATIO(builder, SYMBOL_TO_NOISE_RATIO)
+
+def RFOAddBIT_ERROR_RATE(builder, BIT_ERROR_RATE):
+    builder.PrependFloat64Slot(70, BIT_ERROR_RATE, 0.0)
+
+def AddBIT_ERROR_RATE(builder, BIT_ERROR_RATE):
+    RFOAddBIT_ERROR_RATE(builder, BIT_ERROR_RATE)
+
+def RFOAddON_ORBIT(builder, ON_ORBIT):
+    builder.PrependUOffsetTRelativeSlot(71, flatbuffers.number_types.UOffsetTFlags.py_type(ON_ORBIT), 0)
+
+def AddON_ORBIT(builder, ON_ORBIT):
+    RFOAddON_ORBIT(builder, ON_ORBIT)
+
+def RFOAddDESCRIPTOR(builder, DESCRIPTOR):
+    builder.PrependUOffsetTRelativeSlot(72, flatbuffers.number_types.UOffsetTFlags.py_type(DESCRIPTOR), 0)
+
+def AddDESCRIPTOR(builder, DESCRIPTOR):
+    RFOAddDESCRIPTOR(builder, DESCRIPTOR)
+
+def RFOAddURL(builder, URL):
+    builder.PrependUOffsetTRelativeSlot(73, flatbuffers.number_types.UOffsetTFlags.py_type(URL), 0)
+
+def AddURL(builder, URL):
+    RFOAddURL(builder, URL)
+
+def RFOEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return RFOEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class RFOT(object):
+
+    # RFOT
+    def __init__(self):
+        self.ID = None  # type: str
+        self.OB_TIME = None  # type: str
+        self.ID_SENSOR = None  # type: str
+        self.TYPE = None  # type: str
+        self.SAT_NO = 0  # type: int
+        self.TASK_ID = None  # type: str
+        self.TRANSACTION_ID = None  # type: str
+        self.TRACK_ID = None  # type: str
+        self.ORIG_OBJECT_ID = None  # type: str
+        self.ORIG_SENSOR_ID = None  # type: str
+        self.UCT = False  # type: bool
+        self.TRANSPONDER = None  # type: str
+        self.AZIMUTH = 0.0  # type: float
+        self.AZIMUTH_UNC = 0.0  # type: float
+        self.AZIMUTH_RATE = 0.0  # type: float
+        self.ELEVATION = 0.0  # type: float
+        self.ELEVATION_UNC = 0.0  # type: float
+        self.ELEVATION_RATE = 0.0  # type: float
+        self.RANGE = 0.0  # type: float
+        self.RANGE_UNC = 0.0  # type: float
+        self.RANGE_RATE = 0.0  # type: float
+        self.RANGE_RATE_UNC = 0.0  # type: float
+        self.TRACK_RANGE = 0.0  # type: float
+        self.SENLAT = 0.0  # type: float
+        self.SENLON = 0.0  # type: float
+        self.SENALT = 0.0  # type: float
+        self.ELNOT = None  # type: str
+        self.FREQUENCY = 0.0  # type: float
+        self.NOMINAL_FREQUENCY = 0.0  # type: float
+        self.START_FREQUENCY = 0.0  # type: float
+        self.END_FREQUENCY = 0.0  # type: float
+        self.RELATIVE_CARRIER_POWER = 0.0  # type: float
+        self.SPECTRUM_ANALYZER_POWER = 0.0  # type: float
+        self.RELATIVE_NOISE_FLOOR = 0.0  # type: float
+        self.REFERENCE_LEVEL = 0.0  # type: float
+        self.PGRI = 0.0  # type: float
+        self.CONFIDENCE = 0.0  # type: float
+        self.INCOMING = False  # type: bool
+        self.SWITCH_POINT = 0  # type: int
+        self.BAUD_RATE = 0.0  # type: float
+        self.SNR = 0.0  # type: float
+        self.NOMINAL_SNR = 0.0  # type: float
+        self.POLARITY = 0.0  # type: float
+        self.POLARITY_TYPE = None  # type: str
+        self.CHANNEL = 0  # type: int
+        self.POWER_OVER_NOISE = 0.0  # type: float
+        self.NOMINAL_POWER_OVER_NOISE = 0.0  # type: float
+        self.BANDWIDTH = 0.0  # type: float
+        self.NOMINAL_BANDWIDTH = 0.0  # type: float
+        self.RESOLUTION_BANDWIDTH = 0.0  # type: float
+        self.VIDEO_BANDWIDTH = 0.0  # type: float
+        self.EIRP = 0.0  # type: float
+        self.NOMINAL_EIRP = 0.0  # type: float
+        self.MIN_PSD = 0.0  # type: float
+        self.MAX_PSD = 0.0  # type: float
+        self.FREQUENCY_SHIFT = 0.0  # type: float
+        self.PEAK = False  # type: bool
+        self.ANTENNA_NAME = None  # type: str
+        self.DETECTION_STATUS = None  # type: str
+        self.COLLECTION_MODE = None  # type: str
+        self.RAW_FILE_URI = None  # type: str
+        self.TAGS = None  # type: List[str]
+        self.NOISE_PWR_DENSITY = 0.0  # type: float
+        self.CARRIER_STANDARD = None  # type: str
+        self.MODULATION = None  # type: str
+        self.INNER_CODING_RATE = 0  # type: int
+        self.OUTER_CODING_RATE = 0  # type: int
+        self.TRANSMIT_FILTER_TYPE = None  # type: str
+        self.TRANSMIT_FILTER_ROLL_OFF = 0.0  # type: float
+        self.SYMBOL_TO_NOISE_RATIO = 0.0  # type: float
+        self.BIT_ERROR_RATE = 0.0  # type: float
+        self.ON_ORBIT = None  # type: str
+        self.DESCRIPTOR = None  # type: str
+        self.URL = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        RFO = RFO()
+        RFO.Init(buf, pos)
+        return cls.InitFromObj(RFO)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, RFO):
+        x = RFOT()
+        x._UnPack(RFO)
+        return x
+
+    # RFOT
+    def _UnPack(self, RFO):
+        if RFO is None:
+            return
+        self.ID = RFO.ID()
+        self.OB_TIME = RFO.OB_TIME()
+        self.ID_SENSOR = RFO.ID_SENSOR()
+        self.TYPE = RFO.TYPE()
+        self.SAT_NO = RFO.SAT_NO()
+        self.TASK_ID = RFO.TASK_ID()
+        self.TRANSACTION_ID = RFO.TRANSACTION_ID()
+        self.TRACK_ID = RFO.TRACK_ID()
+        self.ORIG_OBJECT_ID = RFO.ORIG_OBJECT_ID()
+        self.ORIG_SENSOR_ID = RFO.ORIG_SENSOR_ID()
+        self.UCT = RFO.UCT()
+        self.TRANSPONDER = RFO.TRANSPONDER()
+        self.AZIMUTH = RFO.AZIMUTH()
+        self.AZIMUTH_UNC = RFO.AZIMUTH_UNC()
+        self.AZIMUTH_RATE = RFO.AZIMUTH_RATE()
+        self.ELEVATION = RFO.ELEVATION()
+        self.ELEVATION_UNC = RFO.ELEVATION_UNC()
+        self.ELEVATION_RATE = RFO.ELEVATION_RATE()
+        self.RANGE = RFO.RANGE()
+        self.RANGE_UNC = RFO.RANGE_UNC()
+        self.RANGE_RATE = RFO.RANGE_RATE()
+        self.RANGE_RATE_UNC = RFO.RANGE_RATE_UNC()
+        self.TRACK_RANGE = RFO.TRACK_RANGE()
+        self.SENLAT = RFO.SENLAT()
+        self.SENLON = RFO.SENLON()
+        self.SENALT = RFO.SENALT()
+        self.ELNOT = RFO.ELNOT()
+        self.FREQUENCY = RFO.FREQUENCY()
+        self.NOMINAL_FREQUENCY = RFO.NOMINAL_FREQUENCY()
+        self.START_FREQUENCY = RFO.START_FREQUENCY()
+        self.END_FREQUENCY = RFO.END_FREQUENCY()
+        self.RELATIVE_CARRIER_POWER = RFO.RELATIVE_CARRIER_POWER()
+        self.SPECTRUM_ANALYZER_POWER = RFO.SPECTRUM_ANALYZER_POWER()
+        self.RELATIVE_NOISE_FLOOR = RFO.RELATIVE_NOISE_FLOOR()
+        self.REFERENCE_LEVEL = RFO.REFERENCE_LEVEL()
+        self.PGRI = RFO.PGRI()
+        self.CONFIDENCE = RFO.CONFIDENCE()
+        self.INCOMING = RFO.INCOMING()
+        self.SWITCH_POINT = RFO.SWITCH_POINT()
+        self.BAUD_RATE = RFO.BAUD_RATE()
+        self.SNR = RFO.SNR()
+        self.NOMINAL_SNR = RFO.NOMINAL_SNR()
+        self.POLARITY = RFO.POLARITY()
+        self.POLARITY_TYPE = RFO.POLARITY_TYPE()
+        self.CHANNEL = RFO.CHANNEL()
+        self.POWER_OVER_NOISE = RFO.POWER_OVER_NOISE()
+        self.NOMINAL_POWER_OVER_NOISE = RFO.NOMINAL_POWER_OVER_NOISE()
+        self.BANDWIDTH = RFO.BANDWIDTH()
+        self.NOMINAL_BANDWIDTH = RFO.NOMINAL_BANDWIDTH()
+        self.RESOLUTION_BANDWIDTH = RFO.RESOLUTION_BANDWIDTH()
+        self.VIDEO_BANDWIDTH = RFO.VIDEO_BANDWIDTH()
+        self.EIRP = RFO.EIRP()
+        self.NOMINAL_EIRP = RFO.NOMINAL_EIRP()
+        self.MIN_PSD = RFO.MIN_PSD()
+        self.MAX_PSD = RFO.MAX_PSD()
+        self.FREQUENCY_SHIFT = RFO.FREQUENCY_SHIFT()
+        self.PEAK = RFO.PEAK()
+        self.ANTENNA_NAME = RFO.ANTENNA_NAME()
+        self.DETECTION_STATUS = RFO.DETECTION_STATUS()
+        self.COLLECTION_MODE = RFO.COLLECTION_MODE()
+        self.RAW_FILE_URI = RFO.RAW_FILE_URI()
+        if not RFO.TAGSIsNone():
+            self.TAGS = []
+            for i in range(RFO.TAGSLength()):
+                self.TAGS.append(RFO.TAGS(i))
+        self.NOISE_PWR_DENSITY = RFO.NOISE_PWR_DENSITY()
+        self.CARRIER_STANDARD = RFO.CARRIER_STANDARD()
+        self.MODULATION = RFO.MODULATION()
+        self.INNER_CODING_RATE = RFO.INNER_CODING_RATE()
+        self.OUTER_CODING_RATE = RFO.OUTER_CODING_RATE()
+        self.TRANSMIT_FILTER_TYPE = RFO.TRANSMIT_FILTER_TYPE()
+        self.TRANSMIT_FILTER_ROLL_OFF = RFO.TRANSMIT_FILTER_ROLL_OFF()
+        self.SYMBOL_TO_NOISE_RATIO = RFO.SYMBOL_TO_NOISE_RATIO()
+        self.BIT_ERROR_RATE = RFO.BIT_ERROR_RATE()
+        self.ON_ORBIT = RFO.ON_ORBIT()
+        self.DESCRIPTOR = RFO.DESCRIPTOR()
+        self.URL = RFO.URL()
+
+    # RFOT
+    def Pack(self, builder):
+        if self.ID is not None:
+            ID = builder.CreateString(self.ID)
+        if self.OB_TIME is not None:
+            OB_TIME = builder.CreateString(self.OB_TIME)
+        if self.ID_SENSOR is not None:
+            ID_SENSOR = builder.CreateString(self.ID_SENSOR)
+        if self.TYPE is not None:
+            TYPE = builder.CreateString(self.TYPE)
+        if self.TASK_ID is not None:
+            TASK_ID = builder.CreateString(self.TASK_ID)
+        if self.TRANSACTION_ID is not None:
+            TRANSACTION_ID = builder.CreateString(self.TRANSACTION_ID)
+        if self.TRACK_ID is not None:
+            TRACK_ID = builder.CreateString(self.TRACK_ID)
+        if self.ORIG_OBJECT_ID is not None:
+            ORIG_OBJECT_ID = builder.CreateString(self.ORIG_OBJECT_ID)
+        if self.ORIG_SENSOR_ID is not None:
+            ORIG_SENSOR_ID = builder.CreateString(self.ORIG_SENSOR_ID)
+        if self.TRANSPONDER is not None:
+            TRANSPONDER = builder.CreateString(self.TRANSPONDER)
+        if self.ELNOT is not None:
+            ELNOT = builder.CreateString(self.ELNOT)
+        if self.POLARITY_TYPE is not None:
+            POLARITY_TYPE = builder.CreateString(self.POLARITY_TYPE)
+        if self.ANTENNA_NAME is not None:
+            ANTENNA_NAME = builder.CreateString(self.ANTENNA_NAME)
+        if self.DETECTION_STATUS is not None:
+            DETECTION_STATUS = builder.CreateString(self.DETECTION_STATUS)
+        if self.COLLECTION_MODE is not None:
+            COLLECTION_MODE = builder.CreateString(self.COLLECTION_MODE)
+        if self.RAW_FILE_URI is not None:
+            RAW_FILE_URI = builder.CreateString(self.RAW_FILE_URI)
+        if self.TAGS is not None:
+            TAGSlist = []
+            for i in range(len(self.TAGS)):
+                TAGSlist.append(builder.CreateString(self.TAGS[i]))
+            RFOStartTAGSVector(builder, len(self.TAGS))
+            for i in reversed(range(len(self.TAGS))):
+                builder.PrependUOffsetTRelative(TAGSlist[i])
+            TAGS = builder.EndVector()
+        if self.CARRIER_STANDARD is not None:
+            CARRIER_STANDARD = builder.CreateString(self.CARRIER_STANDARD)
+        if self.MODULATION is not None:
+            MODULATION = builder.CreateString(self.MODULATION)
+        if self.TRANSMIT_FILTER_TYPE is not None:
+            TRANSMIT_FILTER_TYPE = builder.CreateString(self.TRANSMIT_FILTER_TYPE)
+        if self.ON_ORBIT is not None:
+            ON_ORBIT = builder.CreateString(self.ON_ORBIT)
+        if self.DESCRIPTOR is not None:
+            DESCRIPTOR = builder.CreateString(self.DESCRIPTOR)
+        if self.URL is not None:
+            URL = builder.CreateString(self.URL)
+        RFOStart(builder)
+        if self.ID is not None:
+            RFOAddID(builder, ID)
+        if self.OB_TIME is not None:
+            RFOAddOB_TIME(builder, OB_TIME)
+        if self.ID_SENSOR is not None:
+            RFOAddID_SENSOR(builder, ID_SENSOR)
+        if self.TYPE is not None:
+            RFOAddTYPE(builder, TYPE)
+        RFOAddSAT_NO(builder, self.SAT_NO)
+        if self.TASK_ID is not None:
+            RFOAddTASK_ID(builder, TASK_ID)
+        if self.TRANSACTION_ID is not None:
+            RFOAddTRANSACTION_ID(builder, TRANSACTION_ID)
+        if self.TRACK_ID is not None:
+            RFOAddTRACK_ID(builder, TRACK_ID)
+        if self.ORIG_OBJECT_ID is not None:
+            RFOAddORIG_OBJECT_ID(builder, ORIG_OBJECT_ID)
+        if self.ORIG_SENSOR_ID is not None:
+            RFOAddORIG_SENSOR_ID(builder, ORIG_SENSOR_ID)
+        RFOAddUCT(builder, self.UCT)
+        if self.TRANSPONDER is not None:
+            RFOAddTRANSPONDER(builder, TRANSPONDER)
+        RFOAddAZIMUTH(builder, self.AZIMUTH)
+        RFOAddAZIMUTH_UNC(builder, self.AZIMUTH_UNC)
+        RFOAddAZIMUTH_RATE(builder, self.AZIMUTH_RATE)
+        RFOAddELEVATION(builder, self.ELEVATION)
+        RFOAddELEVATION_UNC(builder, self.ELEVATION_UNC)
+        RFOAddELEVATION_RATE(builder, self.ELEVATION_RATE)
+        RFOAddRANGE(builder, self.RANGE)
+        RFOAddRANGE_UNC(builder, self.RANGE_UNC)
+        RFOAddRANGE_RATE(builder, self.RANGE_RATE)
+        RFOAddRANGE_RATE_UNC(builder, self.RANGE_RATE_UNC)
+        RFOAddTRACK_RANGE(builder, self.TRACK_RANGE)
+        RFOAddSENLAT(builder, self.SENLAT)
+        RFOAddSENLON(builder, self.SENLON)
+        RFOAddSENALT(builder, self.SENALT)
+        if self.ELNOT is not None:
+            RFOAddELNOT(builder, ELNOT)
+        RFOAddFREQUENCY(builder, self.FREQUENCY)
+        RFOAddNOMINAL_FREQUENCY(builder, self.NOMINAL_FREQUENCY)
+        RFOAddSTART_FREQUENCY(builder, self.START_FREQUENCY)
+        RFOAddEND_FREQUENCY(builder, self.END_FREQUENCY)
+        RFOAddRELATIVE_CARRIER_POWER(builder, self.RELATIVE_CARRIER_POWER)
+        RFOAddSPECTRUM_ANALYZER_POWER(builder, self.SPECTRUM_ANALYZER_POWER)
+        RFOAddRELATIVE_NOISE_FLOOR(builder, self.RELATIVE_NOISE_FLOOR)
+        RFOAddREFERENCE_LEVEL(builder, self.REFERENCE_LEVEL)
+        RFOAddPGRI(builder, self.PGRI)
+        RFOAddCONFIDENCE(builder, self.CONFIDENCE)
+        RFOAddINCOMING(builder, self.INCOMING)
+        RFOAddSWITCH_POINT(builder, self.SWITCH_POINT)
+        RFOAddBAUD_RATE(builder, self.BAUD_RATE)
+        RFOAddSNR(builder, self.SNR)
+        RFOAddNOMINAL_SNR(builder, self.NOMINAL_SNR)
+        RFOAddPOLARITY(builder, self.POLARITY)
+        if self.POLARITY_TYPE is not None:
+            RFOAddPOLARITY_TYPE(builder, POLARITY_TYPE)
+        RFOAddCHANNEL(builder, self.CHANNEL)
+        RFOAddPOWER_OVER_NOISE(builder, self.POWER_OVER_NOISE)
+        RFOAddNOMINAL_POWER_OVER_NOISE(builder, self.NOMINAL_POWER_OVER_NOISE)
+        RFOAddBANDWIDTH(builder, self.BANDWIDTH)
+        RFOAddNOMINAL_BANDWIDTH(builder, self.NOMINAL_BANDWIDTH)
+        RFOAddRESOLUTION_BANDWIDTH(builder, self.RESOLUTION_BANDWIDTH)
+        RFOAddVIDEO_BANDWIDTH(builder, self.VIDEO_BANDWIDTH)
+        RFOAddEIRP(builder, self.EIRP)
+        RFOAddNOMINAL_EIRP(builder, self.NOMINAL_EIRP)
+        RFOAddMIN_PSD(builder, self.MIN_PSD)
+        RFOAddMAX_PSD(builder, self.MAX_PSD)
+        RFOAddFREQUENCY_SHIFT(builder, self.FREQUENCY_SHIFT)
+        RFOAddPEAK(builder, self.PEAK)
+        if self.ANTENNA_NAME is not None:
+            RFOAddANTENNA_NAME(builder, ANTENNA_NAME)
+        if self.DETECTION_STATUS is not None:
+            RFOAddDETECTION_STATUS(builder, DETECTION_STATUS)
+        if self.COLLECTION_MODE is not None:
+            RFOAddCOLLECTION_MODE(builder, COLLECTION_MODE)
+        if self.RAW_FILE_URI is not None:
+            RFOAddRAW_FILE_URI(builder, RAW_FILE_URI)
+        if self.TAGS is not None:
+            RFOAddTAGS(builder, TAGS)
+        RFOAddNOISE_PWR_DENSITY(builder, self.NOISE_PWR_DENSITY)
+        if self.CARRIER_STANDARD is not None:
+            RFOAddCARRIER_STANDARD(builder, CARRIER_STANDARD)
+        if self.MODULATION is not None:
+            RFOAddMODULATION(builder, MODULATION)
+        RFOAddINNER_CODING_RATE(builder, self.INNER_CODING_RATE)
+        RFOAddOUTER_CODING_RATE(builder, self.OUTER_CODING_RATE)
+        if self.TRANSMIT_FILTER_TYPE is not None:
+            RFOAddTRANSMIT_FILTER_TYPE(builder, TRANSMIT_FILTER_TYPE)
+        RFOAddTRANSMIT_FILTER_ROLL_OFF(builder, self.TRANSMIT_FILTER_ROLL_OFF)
+        RFOAddSYMBOL_TO_NOISE_RATIO(builder, self.SYMBOL_TO_NOISE_RATIO)
+        RFOAddBIT_ERROR_RATE(builder, self.BIT_ERROR_RATE)
+        if self.ON_ORBIT is not None:
+            RFOAddON_ORBIT(builder, ON_ORBIT)
+        if self.DESCRIPTOR is not None:
+            RFOAddDESCRIPTOR(builder, DESCRIPTOR)
+        if self.URL is not None:
+            RFOAddURL(builder, URL)
+        RFO = RFOEnd(builder)
+        return RFO