spacedatastandards.org 1.73.0__py3-none-any.whl

TDM/TDM.py

@@ -0,0 +1,1700 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Tracking Data Message
+class TDM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TDM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTDM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TDMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x54\x44\x4D", size_prefixed=size_prefixed)
+
+    # TDM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unique identifier for the observation OBSERVER -  [Specific CCSDS Document]
+    # TDM
+    def OBSERVER_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
+
+    # Cartesian X coordinate of the OBSERVER location in chosen reference frame
+    # TDM
+    def OBSERVER_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Cartesian Y coordinate of the OBSERVER location in chosen reference frame 
+    # TDM
+    def OBSERVER_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Cartesian Z coordinate of the OBSERVER location in chosen reference frame 
+    # TDM
+    def OBSERVER_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Cartesian X coordinate of the OBSERVER velocity in chosen reference frame
+    # TDM
+    def OBSERVER_VX(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Cartesian Y coordinate of the OBSERVER velocity in chosen reference frame 
+    # TDM
+    def OBSERVER_VY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Cartesian Z coordinate of the OBSERVER velocity in chosen reference frame 
+    # TDM
+    def OBSERVER_VZ(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Reference frame used for OBSERVER location Cartesian coordinates (e.g., ECEF, ECI)
+    # TDM
+    def OBSERVER_POSITION_REFERENCE_FRAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from RFM import RFM
+            obj = RFM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Reference frame used for obs location Cartesian coordinates (e.g., ECEF, ECI)
+    # TDM
+    def OBS_REFERENCE_FRAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from RFM import RFM
+            obj = RFM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Epoch time or observation time, in ISO 8601 UTC format -  CCSDS 503.0-B-1
+    # TDM
+    def EPOCH(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
+
+    # Time interval between observations in seconds (required).
+    # Time reconstruction: time[i] = OBSERVATION_START_TIME + (i * OBSERVATION_STEP_SIZE)
+    # TDM
+    def OBSERVATION_STEP_SIZE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Start time for observation time reconstruction (ISO 8601 UTC format).
+    # TDM
+    def OBSERVATION_START_TIME(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
+
+    # TDM version number -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def CCSDS_TDM_VERS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Comments regarding TDM -  various sections, e.g., Page D-9
+    # TDM
+    def COMMENT(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # TDM
+    def COMMENTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def COMMENTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # Date of TDM creation -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def CREATION_DATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Originator of the TDM -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def ORIGINATOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Start of metadata section -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def META_START(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Time system used -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def TIME_SYSTEM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Start time of the data -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def START_TIME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Stop time of the data -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def STOP_TIME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # First participant in the TDM -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PARTICIPANT_1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Second participant in the TDM -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PARTICIPANT_2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Third participant in the TDM (if applicable) -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PARTICIPANT_3(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Fourth participant in the TDM (if applicable) -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PARTICIPANT_4(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Fifth participant in the TDM (if applicable) -  CCSDS 503.0-B-1, Page D-9, max participants
+    # TDM
+    def PARTICIPANT_5(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Mode of TDM -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def MODE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # First path in TDM -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PATH_1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Second path in TDM (if applicable) -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def PATH_2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Transmit band -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def TRANSMIT_BAND(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Receive band -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def RECEIVE_BAND(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Integration interval -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def INTEGRATION_INTERVAL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Integration reference -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def INTEGRATION_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Receive delay for second participant -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def RECEIVE_DELAY_2(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
+
+    # Receive delay for third participant -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def RECEIVE_DELAY_3(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
+
+    # Data quality -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def DATA_QUALITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # End of metadata section -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def META_STOP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Start of data section -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def DATA_START(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Transmit frequency for first participant -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def TRANSMIT_FREQ_1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Receive frequency -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def RECEIVE_FREQ(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def RECEIVE_FREQAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def RECEIVE_FREQLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def RECEIVE_FREQIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        return o == 0
+
+    # End of data section -  CCSDS 503.0-B-1, Page D-9
+    # TDM
+    def DATA_STOP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Additional properties as required by the specific application of the TDM...
+    # Reference for time tagging -  CCSDS 503.0-B-1, Page D-10
+    # TDM
+    def TIMETAG_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Type of angle data -  CCSDS 503.0-B-1, Page D-12
+    # Can be AZEL, RADEC, XEYN, XSYE, or another value with provided ICD
+    # TDM
+    def ANGLE_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # First angle value -  CCSDS 503.0-B-1, Page D-12
+    # TDM
+    def ANGLE_1(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # TDM
+    def ANGLE_1AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+        return 0
+
+    # TDM
+    def ANGLE_1Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def ANGLE_1IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        return o == 0
+
+    # Second angle value -  CCSDS 503.0-B-1, Page D-12
+    # TDM
+    def ANGLE_2(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # TDM
+    def ANGLE_2AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+        return 0
+
+    # TDM
+    def ANGLE_2Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def ANGLE_2IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        return o == 0
+
+    # Uncertainty of first angle -  CCSDS 503.0-B-1
+    # TDM
+    def ANGLE_UNCERTAINTY_1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Uncertainty of second angle -  CCSDS 503.0-B-1
+    # TDM
+    def ANGLE_UNCERTAINTY_2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Rate of change of range -  CCSDS 503.0-B-1
+    # TDM
+    def RANGE_RATE(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
+
+    # Uncertainty in range -  CCSDS 503.0-B-1
+    # TDM
+    def RANGE_UNCERTAINTY(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
+
+    # Mode of range data -  CCSDS 503.0-B-1, Page D-10
+    # TDM
+    def RANGE_MODE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Modulus value for range data -  CCSDS 503.0-B-1, Page D-10
+    # TDM
+    def RANGE_MODULUS(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
+
+    # First correction angle -  CCSDS 503.0-B-1, Page D-12
+    # TDM
+    def CORRECTION_ANGLE_1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Second correction angle -  CCSDS 503.0-B-1, Page D-12
+    # TDM
+    def CORRECTION_ANGLE_2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Indicator of corrections applied -  CCSDS 503.0-B-1, Page D-12
+    # TDM
+    def CORRECTIONS_APPLIED(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Dry component of tropospheric delay -  CCSDS 503.0-B-1, Page D-14
+    # TDM
+    def TROPO_DRY(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def TROPO_DRYAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def TROPO_DRYLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def TROPO_DRYIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
+        return o == 0
+
+    # Wet component of tropospheric delay -  CCSDS 503.0-B-1, Page D-14
+    # TDM
+    def TROPO_WET(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def TROPO_WETAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def TROPO_WETLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def TROPO_WETIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        return o == 0
+
+    # Slant total electron content -  CCSDS 503.0-B-1, Page D-13
+    # TDM
+    def STEC(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def STECAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def STECLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def STECIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        return o == 0
+
+    # Atmospheric pressure -  CCSDS 503.0-B-1, Page D-14
+    # TDM
+    def PRESSURE(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def PRESSUREAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def PRESSURELength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def PRESSUREIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        return o == 0
+
+    # Relative humidity -  CCSDS 503.0-B-1, Page D-14
+    # TDM
+    def RHUMIDITY(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def RHUMIDITYAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def RHUMIDITYLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def RHUMIDITYIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        return o == 0
+
+    # Ambient temperature -  CCSDS 503.0-B-1, Page D-14
+    # TDM
+    def TEMPERATURE(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def TEMPERATUREAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def TEMPERATURELength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def TEMPERATUREIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        return o == 0
+
+    # Clock bias values -  CCSDS 503.0-B-1, Page D-15
+    # TDM
+    def CLOCK_BIAS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def CLOCK_BIASAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def CLOCK_BIASLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def CLOCK_BIASIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        return o == 0
+
+    # Clock drift values -  CCSDS 503.0-B-1, Page D-15
+    # TDM
+    def CLOCK_DRIFT(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TDM
+    def CLOCK_DRIFTAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # TDM
+    def CLOCK_DRIFTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # TDM
+    def CLOCK_DRIFTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        return o == 0
+
+def TDMStart(builder):
+    builder.StartObject(61)
+
+def Start(builder):
+    TDMStart(builder)
+
+def TDMAddOBSERVER_ID(builder, OBSERVER_ID):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(OBSERVER_ID), 0)
+
+def AddOBSERVER_ID(builder, OBSERVER_ID):
+    TDMAddOBSERVER_ID(builder, OBSERVER_ID)
+
+def TDMAddOBSERVER_X(builder, OBSERVER_X):
+    builder.PrependFloat64Slot(1, OBSERVER_X, 0.0)
+
+def AddOBSERVER_X(builder, OBSERVER_X):
+    TDMAddOBSERVER_X(builder, OBSERVER_X)
+
+def TDMAddOBSERVER_Y(builder, OBSERVER_Y):
+    builder.PrependFloat64Slot(2, OBSERVER_Y, 0.0)
+
+def AddOBSERVER_Y(builder, OBSERVER_Y):
+    TDMAddOBSERVER_Y(builder, OBSERVER_Y)
+
+def TDMAddOBSERVER_Z(builder, OBSERVER_Z):
+    builder.PrependFloat64Slot(3, OBSERVER_Z, 0.0)
+
+def AddOBSERVER_Z(builder, OBSERVER_Z):
+    TDMAddOBSERVER_Z(builder, OBSERVER_Z)
+
+def TDMAddOBSERVER_VX(builder, OBSERVER_VX):
+    builder.PrependFloat64Slot(4, OBSERVER_VX, 0.0)
+
+def AddOBSERVER_VX(builder, OBSERVER_VX):
+    TDMAddOBSERVER_VX(builder, OBSERVER_VX)
+
+def TDMAddOBSERVER_VY(builder, OBSERVER_VY):
+    builder.PrependFloat64Slot(5, OBSERVER_VY, 0.0)
+
+def AddOBSERVER_VY(builder, OBSERVER_VY):
+    TDMAddOBSERVER_VY(builder, OBSERVER_VY)
+
+def TDMAddOBSERVER_VZ(builder, OBSERVER_VZ):
+    builder.PrependFloat64Slot(6, OBSERVER_VZ, 0.0)
+
+def AddOBSERVER_VZ(builder, OBSERVER_VZ):
+    TDMAddOBSERVER_VZ(builder, OBSERVER_VZ)
+
+def TDMAddOBSERVER_POSITION_REFERENCE_FRAME(builder, OBSERVER_POSITION_REFERENCE_FRAME):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(OBSERVER_POSITION_REFERENCE_FRAME), 0)
+
+def AddOBSERVER_POSITION_REFERENCE_FRAME(builder, OBSERVER_POSITION_REFERENCE_FRAME):
+    TDMAddOBSERVER_POSITION_REFERENCE_FRAME(builder, OBSERVER_POSITION_REFERENCE_FRAME)
+
+def TDMAddOBS_REFERENCE_FRAME(builder, OBS_REFERENCE_FRAME):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(OBS_REFERENCE_FRAME), 0)
+
+def AddOBS_REFERENCE_FRAME(builder, OBS_REFERENCE_FRAME):
+    TDMAddOBS_REFERENCE_FRAME(builder, OBS_REFERENCE_FRAME)
+
+def TDMAddEPOCH(builder, EPOCH):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(EPOCH), 0)
+
+def AddEPOCH(builder, EPOCH):
+    TDMAddEPOCH(builder, EPOCH)
+
+def TDMAddOBSERVATION_STEP_SIZE(builder, OBSERVATION_STEP_SIZE):
+    builder.PrependFloat64Slot(10, OBSERVATION_STEP_SIZE, 0.0)
+
+def AddOBSERVATION_STEP_SIZE(builder, OBSERVATION_STEP_SIZE):
+    TDMAddOBSERVATION_STEP_SIZE(builder, OBSERVATION_STEP_SIZE)
+
+def TDMAddOBSERVATION_START_TIME(builder, OBSERVATION_START_TIME):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(OBSERVATION_START_TIME), 0)
+
+def AddOBSERVATION_START_TIME(builder, OBSERVATION_START_TIME):
+    TDMAddOBSERVATION_START_TIME(builder, OBSERVATION_START_TIME)
+
+def TDMAddCCSDS_TDM_VERS(builder, CCSDS_TDM_VERS):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(CCSDS_TDM_VERS), 0)
+
+def AddCCSDS_TDM_VERS(builder, CCSDS_TDM_VERS):
+    TDMAddCCSDS_TDM_VERS(builder, CCSDS_TDM_VERS)
+
+def TDMAddCOMMENT(builder, COMMENT):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(COMMENT), 0)
+
+def AddCOMMENT(builder, COMMENT):
+    TDMAddCOMMENT(builder, COMMENT)
+
+def TDMStartCOMMENTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCOMMENTVector(builder, numElems):
+    return TDMStartCOMMENTVector(builder, numElems)
+
+def TDMAddCREATION_DATE(builder, CREATION_DATE):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(CREATION_DATE), 0)
+
+def AddCREATION_DATE(builder, CREATION_DATE):
+    TDMAddCREATION_DATE(builder, CREATION_DATE)
+
+def TDMAddORIGINATOR(builder, ORIGINATOR):
+    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(ORIGINATOR), 0)
+
+def AddORIGINATOR(builder, ORIGINATOR):
+    TDMAddORIGINATOR(builder, ORIGINATOR)
+
+def TDMAddMETA_START(builder, META_START):
+    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(META_START), 0)
+
+def AddMETA_START(builder, META_START):
+    TDMAddMETA_START(builder, META_START)
+
+def TDMAddTIME_SYSTEM(builder, TIME_SYSTEM):
+    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(TIME_SYSTEM), 0)
+
+def AddTIME_SYSTEM(builder, TIME_SYSTEM):
+    TDMAddTIME_SYSTEM(builder, TIME_SYSTEM)
+
+def TDMAddSTART_TIME(builder, START_TIME):
+    builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(START_TIME), 0)
+
+def AddSTART_TIME(builder, START_TIME):
+    TDMAddSTART_TIME(builder, START_TIME)
+
+def TDMAddSTOP_TIME(builder, STOP_TIME):
+    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(STOP_TIME), 0)
+
+def AddSTOP_TIME(builder, STOP_TIME):
+    TDMAddSTOP_TIME(builder, STOP_TIME)
+
+def TDMAddPARTICIPANT_1(builder, PARTICIPANT_1):
+    builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(PARTICIPANT_1), 0)
+
+def AddPARTICIPANT_1(builder, PARTICIPANT_1):
+    TDMAddPARTICIPANT_1(builder, PARTICIPANT_1)
+
+def TDMAddPARTICIPANT_2(builder, PARTICIPANT_2):
+    builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(PARTICIPANT_2), 0)
+
+def AddPARTICIPANT_2(builder, PARTICIPANT_2):
+    TDMAddPARTICIPANT_2(builder, PARTICIPANT_2)
+
+def TDMAddPARTICIPANT_3(builder, PARTICIPANT_3):
+    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(PARTICIPANT_3), 0)
+
+def AddPARTICIPANT_3(builder, PARTICIPANT_3):
+    TDMAddPARTICIPANT_3(builder, PARTICIPANT_3)
+
+def TDMAddPARTICIPANT_4(builder, PARTICIPANT_4):
+    builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(PARTICIPANT_4), 0)
+
+def AddPARTICIPANT_4(builder, PARTICIPANT_4):
+    TDMAddPARTICIPANT_4(builder, PARTICIPANT_4)
+
+def TDMAddPARTICIPANT_5(builder, PARTICIPANT_5):
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(PARTICIPANT_5), 0)
+
+def AddPARTICIPANT_5(builder, PARTICIPANT_5):
+    TDMAddPARTICIPANT_5(builder, PARTICIPANT_5)
+
+def TDMAddMODE(builder, MODE):
+    builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(MODE), 0)
+
+def AddMODE(builder, MODE):
+    TDMAddMODE(builder, MODE)
+
+def TDMAddPATH_1(builder, PATH_1):
+    builder.PrependUint16Slot(26, PATH_1, 0)
+
+def AddPATH_1(builder, PATH_1):
+    TDMAddPATH_1(builder, PATH_1)
+
+def TDMAddPATH_2(builder, PATH_2):
+    builder.PrependUint16Slot(27, PATH_2, 0)
+
+def AddPATH_2(builder, PATH_2):
+    TDMAddPATH_2(builder, PATH_2)
+
+def TDMAddTRANSMIT_BAND(builder, TRANSMIT_BAND):
+    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSMIT_BAND), 0)
+
+def AddTRANSMIT_BAND(builder, TRANSMIT_BAND):
+    TDMAddTRANSMIT_BAND(builder, TRANSMIT_BAND)
+
+def TDMAddRECEIVE_BAND(builder, RECEIVE_BAND):
+    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(RECEIVE_BAND), 0)
+
+def AddRECEIVE_BAND(builder, RECEIVE_BAND):
+    TDMAddRECEIVE_BAND(builder, RECEIVE_BAND)
+
+def TDMAddINTEGRATION_INTERVAL(builder, INTEGRATION_INTERVAL):
+    builder.PrependFloat32Slot(30, INTEGRATION_INTERVAL, 0.0)
+
+def AddINTEGRATION_INTERVAL(builder, INTEGRATION_INTERVAL):
+    TDMAddINTEGRATION_INTERVAL(builder, INTEGRATION_INTERVAL)
+
+def TDMAddINTEGRATION_REF(builder, INTEGRATION_REF):
+    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(INTEGRATION_REF), 0)
+
+def AddINTEGRATION_REF(builder, INTEGRATION_REF):
+    TDMAddINTEGRATION_REF(builder, INTEGRATION_REF)
+
+def TDMAddRECEIVE_DELAY_2(builder, RECEIVE_DELAY_2):
+    builder.PrependFloat64Slot(32, RECEIVE_DELAY_2, 0.0)
+
+def AddRECEIVE_DELAY_2(builder, RECEIVE_DELAY_2):
+    TDMAddRECEIVE_DELAY_2(builder, RECEIVE_DELAY_2)
+
+def TDMAddRECEIVE_DELAY_3(builder, RECEIVE_DELAY_3):
+    builder.PrependFloat64Slot(33, RECEIVE_DELAY_3, 0.0)
+
+def AddRECEIVE_DELAY_3(builder, RECEIVE_DELAY_3):
+    TDMAddRECEIVE_DELAY_3(builder, RECEIVE_DELAY_3)
+
+def TDMAddDATA_QUALITY(builder, DATA_QUALITY):
+    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_QUALITY), 0)
+
+def AddDATA_QUALITY(builder, DATA_QUALITY):
+    TDMAddDATA_QUALITY(builder, DATA_QUALITY)
+
+def TDMAddMETA_STOP(builder, META_STOP):
+    builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(META_STOP), 0)
+
+def AddMETA_STOP(builder, META_STOP):
+    TDMAddMETA_STOP(builder, META_STOP)
+
+def TDMAddDATA_START(builder, DATA_START):
+    builder.PrependUOffsetTRelativeSlot(36, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_START), 0)
+
+def AddDATA_START(builder, DATA_START):
+    TDMAddDATA_START(builder, DATA_START)
+
+def TDMAddTRANSMIT_FREQ_1(builder, TRANSMIT_FREQ_1):
+    builder.PrependFloat64Slot(37, TRANSMIT_FREQ_1, 0.0)
+
+def AddTRANSMIT_FREQ_1(builder, TRANSMIT_FREQ_1):
+    TDMAddTRANSMIT_FREQ_1(builder, TRANSMIT_FREQ_1)
+
+def TDMAddRECEIVE_FREQ(builder, RECEIVE_FREQ):
+    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(RECEIVE_FREQ), 0)
+
+def AddRECEIVE_FREQ(builder, RECEIVE_FREQ):
+    TDMAddRECEIVE_FREQ(builder, RECEIVE_FREQ)
+
+def TDMStartRECEIVE_FREQVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartRECEIVE_FREQVector(builder, numElems):
+    return TDMStartRECEIVE_FREQVector(builder, numElems)
+
+def TDMAddDATA_STOP(builder, DATA_STOP):
+    builder.PrependUOffsetTRelativeSlot(39, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_STOP), 0)
+
+def AddDATA_STOP(builder, DATA_STOP):
+    TDMAddDATA_STOP(builder, DATA_STOP)
+
+def TDMAddTIMETAG_REF(builder, TIMETAG_REF):
+    builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(TIMETAG_REF), 0)
+
+def AddTIMETAG_REF(builder, TIMETAG_REF):
+    TDMAddTIMETAG_REF(builder, TIMETAG_REF)
+
+def TDMAddANGLE_TYPE(builder, ANGLE_TYPE):
+    builder.PrependUOffsetTRelativeSlot(41, flatbuffers.number_types.UOffsetTFlags.py_type(ANGLE_TYPE), 0)
+
+def AddANGLE_TYPE(builder, ANGLE_TYPE):
+    TDMAddANGLE_TYPE(builder, ANGLE_TYPE)
+
+def TDMAddANGLE_1(builder, ANGLE_1):
+    builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(ANGLE_1), 0)
+
+def AddANGLE_1(builder, ANGLE_1):
+    TDMAddANGLE_1(builder, ANGLE_1)
+
+def TDMStartANGLE_1Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartANGLE_1Vector(builder, numElems):
+    return TDMStartANGLE_1Vector(builder, numElems)
+
+def TDMAddANGLE_2(builder, ANGLE_2):
+    builder.PrependUOffsetTRelativeSlot(43, flatbuffers.number_types.UOffsetTFlags.py_type(ANGLE_2), 0)
+
+def AddANGLE_2(builder, ANGLE_2):
+    TDMAddANGLE_2(builder, ANGLE_2)
+
+def TDMStartANGLE_2Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartANGLE_2Vector(builder, numElems):
+    return TDMStartANGLE_2Vector(builder, numElems)
+
+def TDMAddANGLE_UNCERTAINTY_1(builder, ANGLE_UNCERTAINTY_1):
+    builder.PrependFloat32Slot(44, ANGLE_UNCERTAINTY_1, 0.0)
+
+def AddANGLE_UNCERTAINTY_1(builder, ANGLE_UNCERTAINTY_1):
+    TDMAddANGLE_UNCERTAINTY_1(builder, ANGLE_UNCERTAINTY_1)
+
+def TDMAddANGLE_UNCERTAINTY_2(builder, ANGLE_UNCERTAINTY_2):
+    builder.PrependFloat32Slot(45, ANGLE_UNCERTAINTY_2, 0.0)
+
+def AddANGLE_UNCERTAINTY_2(builder, ANGLE_UNCERTAINTY_2):
+    TDMAddANGLE_UNCERTAINTY_2(builder, ANGLE_UNCERTAINTY_2)
+
+def TDMAddRANGE_RATE(builder, RANGE_RATE):
+    builder.PrependFloat64Slot(46, RANGE_RATE, 0.0)
+
+def AddRANGE_RATE(builder, RANGE_RATE):
+    TDMAddRANGE_RATE(builder, RANGE_RATE)
+
+def TDMAddRANGE_UNCERTAINTY(builder, RANGE_UNCERTAINTY):
+    builder.PrependFloat64Slot(47, RANGE_UNCERTAINTY, 0.0)
+
+def AddRANGE_UNCERTAINTY(builder, RANGE_UNCERTAINTY):
+    TDMAddRANGE_UNCERTAINTY(builder, RANGE_UNCERTAINTY)
+
+def TDMAddRANGE_MODE(builder, RANGE_MODE):
+    builder.PrependUOffsetTRelativeSlot(48, flatbuffers.number_types.UOffsetTFlags.py_type(RANGE_MODE), 0)
+
+def AddRANGE_MODE(builder, RANGE_MODE):
+    TDMAddRANGE_MODE(builder, RANGE_MODE)
+
+def TDMAddRANGE_MODULUS(builder, RANGE_MODULUS):
+    builder.PrependFloat64Slot(49, RANGE_MODULUS, 0.0)
+
+def AddRANGE_MODULUS(builder, RANGE_MODULUS):
+    TDMAddRANGE_MODULUS(builder, RANGE_MODULUS)
+
+def TDMAddCORRECTION_ANGLE_1(builder, CORRECTION_ANGLE_1):
+    builder.PrependFloat32Slot(50, CORRECTION_ANGLE_1, 0.0)
+
+def AddCORRECTION_ANGLE_1(builder, CORRECTION_ANGLE_1):
+    TDMAddCORRECTION_ANGLE_1(builder, CORRECTION_ANGLE_1)
+
+def TDMAddCORRECTION_ANGLE_2(builder, CORRECTION_ANGLE_2):
+    builder.PrependFloat32Slot(51, CORRECTION_ANGLE_2, 0.0)
+
+def AddCORRECTION_ANGLE_2(builder, CORRECTION_ANGLE_2):
+    TDMAddCORRECTION_ANGLE_2(builder, CORRECTION_ANGLE_2)
+
+def TDMAddCORRECTIONS_APPLIED(builder, CORRECTIONS_APPLIED):
+    builder.PrependUOffsetTRelativeSlot(52, flatbuffers.number_types.UOffsetTFlags.py_type(CORRECTIONS_APPLIED), 0)
+
+def AddCORRECTIONS_APPLIED(builder, CORRECTIONS_APPLIED):
+    TDMAddCORRECTIONS_APPLIED(builder, CORRECTIONS_APPLIED)
+
+def TDMAddTROPO_DRY(builder, TROPO_DRY):
+    builder.PrependUOffsetTRelativeSlot(53, flatbuffers.number_types.UOffsetTFlags.py_type(TROPO_DRY), 0)
+
+def AddTROPO_DRY(builder, TROPO_DRY):
+    TDMAddTROPO_DRY(builder, TROPO_DRY)
+
+def TDMStartTROPO_DRYVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartTROPO_DRYVector(builder, numElems):
+    return TDMStartTROPO_DRYVector(builder, numElems)
+
+def TDMAddTROPO_WET(builder, TROPO_WET):
+    builder.PrependUOffsetTRelativeSlot(54, flatbuffers.number_types.UOffsetTFlags.py_type(TROPO_WET), 0)
+
+def AddTROPO_WET(builder, TROPO_WET):
+    TDMAddTROPO_WET(builder, TROPO_WET)
+
+def TDMStartTROPO_WETVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartTROPO_WETVector(builder, numElems):
+    return TDMStartTROPO_WETVector(builder, numElems)
+
+def TDMAddSTEC(builder, STEC):
+    builder.PrependUOffsetTRelativeSlot(55, flatbuffers.number_types.UOffsetTFlags.py_type(STEC), 0)
+
+def AddSTEC(builder, STEC):
+    TDMAddSTEC(builder, STEC)
+
+def TDMStartSTECVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartSTECVector(builder, numElems):
+    return TDMStartSTECVector(builder, numElems)
+
+def TDMAddPRESSURE(builder, PRESSURE):
+    builder.PrependUOffsetTRelativeSlot(56, flatbuffers.number_types.UOffsetTFlags.py_type(PRESSURE), 0)
+
+def AddPRESSURE(builder, PRESSURE):
+    TDMAddPRESSURE(builder, PRESSURE)
+
+def TDMStartPRESSUREVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartPRESSUREVector(builder, numElems):
+    return TDMStartPRESSUREVector(builder, numElems)
+
+def TDMAddRHUMIDITY(builder, RHUMIDITY):
+    builder.PrependUOffsetTRelativeSlot(57, flatbuffers.number_types.UOffsetTFlags.py_type(RHUMIDITY), 0)
+
+def AddRHUMIDITY(builder, RHUMIDITY):
+    TDMAddRHUMIDITY(builder, RHUMIDITY)
+
+def TDMStartRHUMIDITYVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartRHUMIDITYVector(builder, numElems):
+    return TDMStartRHUMIDITYVector(builder, numElems)
+
+def TDMAddTEMPERATURE(builder, TEMPERATURE):
+    builder.PrependUOffsetTRelativeSlot(58, flatbuffers.number_types.UOffsetTFlags.py_type(TEMPERATURE), 0)
+
+def AddTEMPERATURE(builder, TEMPERATURE):
+    TDMAddTEMPERATURE(builder, TEMPERATURE)
+
+def TDMStartTEMPERATUREVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartTEMPERATUREVector(builder, numElems):
+    return TDMStartTEMPERATUREVector(builder, numElems)
+
+def TDMAddCLOCK_BIAS(builder, CLOCK_BIAS):
+    builder.PrependUOffsetTRelativeSlot(59, flatbuffers.number_types.UOffsetTFlags.py_type(CLOCK_BIAS), 0)
+
+def AddCLOCK_BIAS(builder, CLOCK_BIAS):
+    TDMAddCLOCK_BIAS(builder, CLOCK_BIAS)
+
+def TDMStartCLOCK_BIASVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartCLOCK_BIASVector(builder, numElems):
+    return TDMStartCLOCK_BIASVector(builder, numElems)
+
+def TDMAddCLOCK_DRIFT(builder, CLOCK_DRIFT):
+    builder.PrependUOffsetTRelativeSlot(60, flatbuffers.number_types.UOffsetTFlags.py_type(CLOCK_DRIFT), 0)
+
+def AddCLOCK_DRIFT(builder, CLOCK_DRIFT):
+    TDMAddCLOCK_DRIFT(builder, CLOCK_DRIFT)
+
+def TDMStartCLOCK_DRIFTVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartCLOCK_DRIFTVector(builder, numElems):
+    return TDMStartCLOCK_DRIFTVector(builder, numElems)
+
+def TDMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return TDMEnd(builder)
+
+import RFM
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class TDMT(object):
+
+    # TDMT
+    def __init__(self):
+        self.OBSERVER_ID = None  # type: str
+        self.OBSERVER_X = 0.0  # type: float
+        self.OBSERVER_Y = 0.0  # type: float
+        self.OBSERVER_Z = 0.0  # type: float
+        self.OBSERVER_VX = 0.0  # type: float
+        self.OBSERVER_VY = 0.0  # type: float
+        self.OBSERVER_VZ = 0.0  # type: float
+        self.OBSERVER_POSITION_REFERENCE_FRAME = None  # type: Optional[RFM.RFMT]
+        self.OBS_REFERENCE_FRAME = None  # type: Optional[RFM.RFMT]
+        self.EPOCH = None  # type: str
+        self.OBSERVATION_STEP_SIZE = 0.0  # type: float
+        self.OBSERVATION_START_TIME = None  # type: str
+        self.CCSDS_TDM_VERS = None  # type: str
+        self.COMMENT = None  # type: List[str]
+        self.CREATION_DATE = None  # type: str
+        self.ORIGINATOR = None  # type: str
+        self.META_START = None  # type: str
+        self.TIME_SYSTEM = None  # type: str
+        self.START_TIME = None  # type: str
+        self.STOP_TIME = None  # type: str
+        self.PARTICIPANT_1 = None  # type: str
+        self.PARTICIPANT_2 = None  # type: str
+        self.PARTICIPANT_3 = None  # type: str
+        self.PARTICIPANT_4 = None  # type: str
+        self.PARTICIPANT_5 = None  # type: str
+        self.MODE = None  # type: str
+        self.PATH_1 = 0  # type: int
+        self.PATH_2 = 0  # type: int
+        self.TRANSMIT_BAND = None  # type: str
+        self.RECEIVE_BAND = None  # type: str
+        self.INTEGRATION_INTERVAL = 0.0  # type: float
+        self.INTEGRATION_REF = None  # type: str
+        self.RECEIVE_DELAY_2 = 0.0  # type: float
+        self.RECEIVE_DELAY_3 = 0.0  # type: float
+        self.DATA_QUALITY = None  # type: str
+        self.META_STOP = None  # type: str
+        self.DATA_START = None  # type: str
+        self.TRANSMIT_FREQ_1 = 0.0  # type: float
+        self.RECEIVE_FREQ = None  # type: List[float]
+        self.DATA_STOP = None  # type: str
+        self.TIMETAG_REF = None  # type: str
+        self.ANGLE_TYPE = None  # type: str
+        self.ANGLE_1 = None  # type: List[float]
+        self.ANGLE_2 = None  # type: List[float]
+        self.ANGLE_UNCERTAINTY_1 = 0.0  # type: float
+        self.ANGLE_UNCERTAINTY_2 = 0.0  # type: float
+        self.RANGE_RATE = 0.0  # type: float
+        self.RANGE_UNCERTAINTY = 0.0  # type: float
+        self.RANGE_MODE = None  # type: str
+        self.RANGE_MODULUS = 0.0  # type: float
+        self.CORRECTION_ANGLE_1 = 0.0  # type: float
+        self.CORRECTION_ANGLE_2 = 0.0  # type: float
+        self.CORRECTIONS_APPLIED = None  # type: str
+        self.TROPO_DRY = None  # type: List[float]
+        self.TROPO_WET = None  # type: List[float]
+        self.STEC = None  # type: List[float]
+        self.PRESSURE = None  # type: List[float]
+        self.RHUMIDITY = None  # type: List[float]
+        self.TEMPERATURE = None  # type: List[float]
+        self.CLOCK_BIAS = None  # type: List[float]
+        self.CLOCK_DRIFT = None  # type: List[float]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        TDM = TDM()
+        TDM.Init(buf, pos)
+        return cls.InitFromObj(TDM)
+
+    @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, TDM):
+        x = TDMT()
+        x._UnPack(TDM)
+        return x
+
+    # TDMT
+    def _UnPack(self, TDM):
+        if TDM is None:
+            return
+        self.OBSERVER_ID = TDM.OBSERVER_ID()
+        self.OBSERVER_X = TDM.OBSERVER_X()
+        self.OBSERVER_Y = TDM.OBSERVER_Y()
+        self.OBSERVER_Z = TDM.OBSERVER_Z()
+        self.OBSERVER_VX = TDM.OBSERVER_VX()
+        self.OBSERVER_VY = TDM.OBSERVER_VY()
+        self.OBSERVER_VZ = TDM.OBSERVER_VZ()
+        if TDM.OBSERVER_POSITION_REFERENCE_FRAME() is not None:
+            self.OBSERVER_POSITION_REFERENCE_FRAME = RFM.RFMT.InitFromObj(TDM.OBSERVER_POSITION_REFERENCE_FRAME())
+        if TDM.OBS_REFERENCE_FRAME() is not None:
+            self.OBS_REFERENCE_FRAME = RFM.RFMT.InitFromObj(TDM.OBS_REFERENCE_FRAME())
+        self.EPOCH = TDM.EPOCH()
+        self.OBSERVATION_STEP_SIZE = TDM.OBSERVATION_STEP_SIZE()
+        self.OBSERVATION_START_TIME = TDM.OBSERVATION_START_TIME()
+        self.CCSDS_TDM_VERS = TDM.CCSDS_TDM_VERS()
+        if not TDM.COMMENTIsNone():
+            self.COMMENT = []
+            for i in range(TDM.COMMENTLength()):
+                self.COMMENT.append(TDM.COMMENT(i))
+        self.CREATION_DATE = TDM.CREATION_DATE()
+        self.ORIGINATOR = TDM.ORIGINATOR()
+        self.META_START = TDM.META_START()
+        self.TIME_SYSTEM = TDM.TIME_SYSTEM()
+        self.START_TIME = TDM.START_TIME()
+        self.STOP_TIME = TDM.STOP_TIME()
+        self.PARTICIPANT_1 = TDM.PARTICIPANT_1()
+        self.PARTICIPANT_2 = TDM.PARTICIPANT_2()
+        self.PARTICIPANT_3 = TDM.PARTICIPANT_3()
+        self.PARTICIPANT_4 = TDM.PARTICIPANT_4()
+        self.PARTICIPANT_5 = TDM.PARTICIPANT_5()
+        self.MODE = TDM.MODE()
+        self.PATH_1 = TDM.PATH_1()
+        self.PATH_2 = TDM.PATH_2()
+        self.TRANSMIT_BAND = TDM.TRANSMIT_BAND()
+        self.RECEIVE_BAND = TDM.RECEIVE_BAND()
+        self.INTEGRATION_INTERVAL = TDM.INTEGRATION_INTERVAL()
+        self.INTEGRATION_REF = TDM.INTEGRATION_REF()
+        self.RECEIVE_DELAY_2 = TDM.RECEIVE_DELAY_2()
+        self.RECEIVE_DELAY_3 = TDM.RECEIVE_DELAY_3()
+        self.DATA_QUALITY = TDM.DATA_QUALITY()
+        self.META_STOP = TDM.META_STOP()
+        self.DATA_START = TDM.DATA_START()
+        self.TRANSMIT_FREQ_1 = TDM.TRANSMIT_FREQ_1()
+        if not TDM.RECEIVE_FREQIsNone():
+            if np is None:
+                self.RECEIVE_FREQ = []
+                for i in range(TDM.RECEIVE_FREQLength()):
+                    self.RECEIVE_FREQ.append(TDM.RECEIVE_FREQ(i))
+            else:
+                self.RECEIVE_FREQ = TDM.RECEIVE_FREQAsNumpy()
+        self.DATA_STOP = TDM.DATA_STOP()
+        self.TIMETAG_REF = TDM.TIMETAG_REF()
+        self.ANGLE_TYPE = TDM.ANGLE_TYPE()
+        if not TDM.ANGLE_1IsNone():
+            if np is None:
+                self.ANGLE_1 = []
+                for i in range(TDM.ANGLE_1Length()):
+                    self.ANGLE_1.append(TDM.ANGLE_1(i))
+            else:
+                self.ANGLE_1 = TDM.ANGLE_1AsNumpy()
+        if not TDM.ANGLE_2IsNone():
+            if np is None:
+                self.ANGLE_2 = []
+                for i in range(TDM.ANGLE_2Length()):
+                    self.ANGLE_2.append(TDM.ANGLE_2(i))
+            else:
+                self.ANGLE_2 = TDM.ANGLE_2AsNumpy()
+        self.ANGLE_UNCERTAINTY_1 = TDM.ANGLE_UNCERTAINTY_1()
+        self.ANGLE_UNCERTAINTY_2 = TDM.ANGLE_UNCERTAINTY_2()
+        self.RANGE_RATE = TDM.RANGE_RATE()
+        self.RANGE_UNCERTAINTY = TDM.RANGE_UNCERTAINTY()
+        self.RANGE_MODE = TDM.RANGE_MODE()
+        self.RANGE_MODULUS = TDM.RANGE_MODULUS()
+        self.CORRECTION_ANGLE_1 = TDM.CORRECTION_ANGLE_1()
+        self.CORRECTION_ANGLE_2 = TDM.CORRECTION_ANGLE_2()
+        self.CORRECTIONS_APPLIED = TDM.CORRECTIONS_APPLIED()
+        if not TDM.TROPO_DRYIsNone():
+            if np is None:
+                self.TROPO_DRY = []
+                for i in range(TDM.TROPO_DRYLength()):
+                    self.TROPO_DRY.append(TDM.TROPO_DRY(i))
+            else:
+                self.TROPO_DRY = TDM.TROPO_DRYAsNumpy()
+        if not TDM.TROPO_WETIsNone():
+            if np is None:
+                self.TROPO_WET = []
+                for i in range(TDM.TROPO_WETLength()):
+                    self.TROPO_WET.append(TDM.TROPO_WET(i))
+            else:
+                self.TROPO_WET = TDM.TROPO_WETAsNumpy()
+        if not TDM.STECIsNone():
+            if np is None:
+                self.STEC = []
+                for i in range(TDM.STECLength()):
+                    self.STEC.append(TDM.STEC(i))
+            else:
+                self.STEC = TDM.STECAsNumpy()
+        if not TDM.PRESSUREIsNone():
+            if np is None:
+                self.PRESSURE = []
+                for i in range(TDM.PRESSURELength()):
+                    self.PRESSURE.append(TDM.PRESSURE(i))
+            else:
+                self.PRESSURE = TDM.PRESSUREAsNumpy()
+        if not TDM.RHUMIDITYIsNone():
+            if np is None:
+                self.RHUMIDITY = []
+                for i in range(TDM.RHUMIDITYLength()):
+                    self.RHUMIDITY.append(TDM.RHUMIDITY(i))
+            else:
+                self.RHUMIDITY = TDM.RHUMIDITYAsNumpy()
+        if not TDM.TEMPERATUREIsNone():
+            if np is None:
+                self.TEMPERATURE = []
+                for i in range(TDM.TEMPERATURELength()):
+                    self.TEMPERATURE.append(TDM.TEMPERATURE(i))
+            else:
+                self.TEMPERATURE = TDM.TEMPERATUREAsNumpy()
+        if not TDM.CLOCK_BIASIsNone():
+            if np is None:
+                self.CLOCK_BIAS = []
+                for i in range(TDM.CLOCK_BIASLength()):
+                    self.CLOCK_BIAS.append(TDM.CLOCK_BIAS(i))
+            else:
+                self.CLOCK_BIAS = TDM.CLOCK_BIASAsNumpy()
+        if not TDM.CLOCK_DRIFTIsNone():
+            if np is None:
+                self.CLOCK_DRIFT = []
+                for i in range(TDM.CLOCK_DRIFTLength()):
+                    self.CLOCK_DRIFT.append(TDM.CLOCK_DRIFT(i))
+            else:
+                self.CLOCK_DRIFT = TDM.CLOCK_DRIFTAsNumpy()
+
+    # TDMT
+    def Pack(self, builder):
+        if self.OBSERVER_ID is not None:
+            OBSERVER_ID = builder.CreateString(self.OBSERVER_ID)
+        if self.OBSERVER_POSITION_REFERENCE_FRAME is not None:
+            OBSERVER_POSITION_REFERENCE_FRAME = self.OBSERVER_POSITION_REFERENCE_FRAME.Pack(builder)
+        if self.OBS_REFERENCE_FRAME is not None:
+            OBS_REFERENCE_FRAME = self.OBS_REFERENCE_FRAME.Pack(builder)
+        if self.EPOCH is not None:
+            EPOCH = builder.CreateString(self.EPOCH)
+        if self.OBSERVATION_START_TIME is not None:
+            OBSERVATION_START_TIME = builder.CreateString(self.OBSERVATION_START_TIME)
+        if self.CCSDS_TDM_VERS is not None:
+            CCSDS_TDM_VERS = builder.CreateString(self.CCSDS_TDM_VERS)
+        if self.COMMENT is not None:
+            COMMENTlist = []
+            for i in range(len(self.COMMENT)):
+                COMMENTlist.append(builder.CreateString(self.COMMENT[i]))
+            TDMStartCOMMENTVector(builder, len(self.COMMENT))
+            for i in reversed(range(len(self.COMMENT))):
+                builder.PrependUOffsetTRelative(COMMENTlist[i])
+            COMMENT = builder.EndVector()
+        if self.CREATION_DATE is not None:
+            CREATION_DATE = builder.CreateString(self.CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            ORIGINATOR = builder.CreateString(self.ORIGINATOR)
+        if self.META_START is not None:
+            META_START = builder.CreateString(self.META_START)
+        if self.TIME_SYSTEM is not None:
+            TIME_SYSTEM = builder.CreateString(self.TIME_SYSTEM)
+        if self.START_TIME is not None:
+            START_TIME = builder.CreateString(self.START_TIME)
+        if self.STOP_TIME is not None:
+            STOP_TIME = builder.CreateString(self.STOP_TIME)
+        if self.PARTICIPANT_1 is not None:
+            PARTICIPANT_1 = builder.CreateString(self.PARTICIPANT_1)
+        if self.PARTICIPANT_2 is not None:
+            PARTICIPANT_2 = builder.CreateString(self.PARTICIPANT_2)
+        if self.PARTICIPANT_3 is not None:
+            PARTICIPANT_3 = builder.CreateString(self.PARTICIPANT_3)
+        if self.PARTICIPANT_4 is not None:
+            PARTICIPANT_4 = builder.CreateString(self.PARTICIPANT_4)
+        if self.PARTICIPANT_5 is not None:
+            PARTICIPANT_5 = builder.CreateString(self.PARTICIPANT_5)
+        if self.MODE is not None:
+            MODE = builder.CreateString(self.MODE)
+        if self.TRANSMIT_BAND is not None:
+            TRANSMIT_BAND = builder.CreateString(self.TRANSMIT_BAND)
+        if self.RECEIVE_BAND is not None:
+            RECEIVE_BAND = builder.CreateString(self.RECEIVE_BAND)
+        if self.INTEGRATION_REF is not None:
+            INTEGRATION_REF = builder.CreateString(self.INTEGRATION_REF)
+        if self.DATA_QUALITY is not None:
+            DATA_QUALITY = builder.CreateString(self.DATA_QUALITY)
+        if self.META_STOP is not None:
+            META_STOP = builder.CreateString(self.META_STOP)
+        if self.DATA_START is not None:
+            DATA_START = builder.CreateString(self.DATA_START)
+        if self.RECEIVE_FREQ is not None:
+            if np is not None and type(self.RECEIVE_FREQ) is np.ndarray:
+                RECEIVE_FREQ = builder.CreateNumpyVector(self.RECEIVE_FREQ)
+            else:
+                TDMStartRECEIVE_FREQVector(builder, len(self.RECEIVE_FREQ))
+                for i in reversed(range(len(self.RECEIVE_FREQ))):
+                    builder.PrependFloat64(self.RECEIVE_FREQ[i])
+                RECEIVE_FREQ = builder.EndVector()
+        if self.DATA_STOP is not None:
+            DATA_STOP = builder.CreateString(self.DATA_STOP)
+        if self.TIMETAG_REF is not None:
+            TIMETAG_REF = builder.CreateString(self.TIMETAG_REF)
+        if self.ANGLE_TYPE is not None:
+            ANGLE_TYPE = builder.CreateString(self.ANGLE_TYPE)
+        if self.ANGLE_1 is not None:
+            if np is not None and type(self.ANGLE_1) is np.ndarray:
+                ANGLE_1 = builder.CreateNumpyVector(self.ANGLE_1)
+            else:
+                TDMStartANGLE_1Vector(builder, len(self.ANGLE_1))
+                for i in reversed(range(len(self.ANGLE_1))):
+                    builder.PrependFloat32(self.ANGLE_1[i])
+                ANGLE_1 = builder.EndVector()
+        if self.ANGLE_2 is not None:
+            if np is not None and type(self.ANGLE_2) is np.ndarray:
+                ANGLE_2 = builder.CreateNumpyVector(self.ANGLE_2)
+            else:
+                TDMStartANGLE_2Vector(builder, len(self.ANGLE_2))
+                for i in reversed(range(len(self.ANGLE_2))):
+                    builder.PrependFloat32(self.ANGLE_2[i])
+                ANGLE_2 = builder.EndVector()
+        if self.RANGE_MODE is not None:
+            RANGE_MODE = builder.CreateString(self.RANGE_MODE)
+        if self.CORRECTIONS_APPLIED is not None:
+            CORRECTIONS_APPLIED = builder.CreateString(self.CORRECTIONS_APPLIED)
+        if self.TROPO_DRY is not None:
+            if np is not None and type(self.TROPO_DRY) is np.ndarray:
+                TROPO_DRY = builder.CreateNumpyVector(self.TROPO_DRY)
+            else:
+                TDMStartTROPO_DRYVector(builder, len(self.TROPO_DRY))
+                for i in reversed(range(len(self.TROPO_DRY))):
+                    builder.PrependFloat64(self.TROPO_DRY[i])
+                TROPO_DRY = builder.EndVector()
+        if self.TROPO_WET is not None:
+            if np is not None and type(self.TROPO_WET) is np.ndarray:
+                TROPO_WET = builder.CreateNumpyVector(self.TROPO_WET)
+            else:
+                TDMStartTROPO_WETVector(builder, len(self.TROPO_WET))
+                for i in reversed(range(len(self.TROPO_WET))):
+                    builder.PrependFloat64(self.TROPO_WET[i])
+                TROPO_WET = builder.EndVector()
+        if self.STEC is not None:
+            if np is not None and type(self.STEC) is np.ndarray:
+                STEC = builder.CreateNumpyVector(self.STEC)
+            else:
+                TDMStartSTECVector(builder, len(self.STEC))
+                for i in reversed(range(len(self.STEC))):
+                    builder.PrependFloat64(self.STEC[i])
+                STEC = builder.EndVector()
+        if self.PRESSURE is not None:
+            if np is not None and type(self.PRESSURE) is np.ndarray:
+                PRESSURE = builder.CreateNumpyVector(self.PRESSURE)
+            else:
+                TDMStartPRESSUREVector(builder, len(self.PRESSURE))
+                for i in reversed(range(len(self.PRESSURE))):
+                    builder.PrependFloat64(self.PRESSURE[i])
+                PRESSURE = builder.EndVector()
+        if self.RHUMIDITY is not None:
+            if np is not None and type(self.RHUMIDITY) is np.ndarray:
+                RHUMIDITY = builder.CreateNumpyVector(self.RHUMIDITY)
+            else:
+                TDMStartRHUMIDITYVector(builder, len(self.RHUMIDITY))
+                for i in reversed(range(len(self.RHUMIDITY))):
+                    builder.PrependFloat64(self.RHUMIDITY[i])
+                RHUMIDITY = builder.EndVector()
+        if self.TEMPERATURE is not None:
+            if np is not None and type(self.TEMPERATURE) is np.ndarray:
+                TEMPERATURE = builder.CreateNumpyVector(self.TEMPERATURE)
+            else:
+                TDMStartTEMPERATUREVector(builder, len(self.TEMPERATURE))
+                for i in reversed(range(len(self.TEMPERATURE))):
+                    builder.PrependFloat64(self.TEMPERATURE[i])
+                TEMPERATURE = builder.EndVector()
+        if self.CLOCK_BIAS is not None:
+            if np is not None and type(self.CLOCK_BIAS) is np.ndarray:
+                CLOCK_BIAS = builder.CreateNumpyVector(self.CLOCK_BIAS)
+            else:
+                TDMStartCLOCK_BIASVector(builder, len(self.CLOCK_BIAS))
+                for i in reversed(range(len(self.CLOCK_BIAS))):
+                    builder.PrependFloat64(self.CLOCK_BIAS[i])
+                CLOCK_BIAS = builder.EndVector()
+        if self.CLOCK_DRIFT is not None:
+            if np is not None and type(self.CLOCK_DRIFT) is np.ndarray:
+                CLOCK_DRIFT = builder.CreateNumpyVector(self.CLOCK_DRIFT)
+            else:
+                TDMStartCLOCK_DRIFTVector(builder, len(self.CLOCK_DRIFT))
+                for i in reversed(range(len(self.CLOCK_DRIFT))):
+                    builder.PrependFloat64(self.CLOCK_DRIFT[i])
+                CLOCK_DRIFT = builder.EndVector()
+        TDMStart(builder)
+        if self.OBSERVER_ID is not None:
+            TDMAddOBSERVER_ID(builder, OBSERVER_ID)
+        TDMAddOBSERVER_X(builder, self.OBSERVER_X)
+        TDMAddOBSERVER_Y(builder, self.OBSERVER_Y)
+        TDMAddOBSERVER_Z(builder, self.OBSERVER_Z)
+        TDMAddOBSERVER_VX(builder, self.OBSERVER_VX)
+        TDMAddOBSERVER_VY(builder, self.OBSERVER_VY)
+        TDMAddOBSERVER_VZ(builder, self.OBSERVER_VZ)
+        if self.OBSERVER_POSITION_REFERENCE_FRAME is not None:
+            TDMAddOBSERVER_POSITION_REFERENCE_FRAME(builder, OBSERVER_POSITION_REFERENCE_FRAME)
+        if self.OBS_REFERENCE_FRAME is not None:
+            TDMAddOBS_REFERENCE_FRAME(builder, OBS_REFERENCE_FRAME)
+        if self.EPOCH is not None:
+            TDMAddEPOCH(builder, EPOCH)
+        TDMAddOBSERVATION_STEP_SIZE(builder, self.OBSERVATION_STEP_SIZE)
+        if self.OBSERVATION_START_TIME is not None:
+            TDMAddOBSERVATION_START_TIME(builder, OBSERVATION_START_TIME)
+        if self.CCSDS_TDM_VERS is not None:
+            TDMAddCCSDS_TDM_VERS(builder, CCSDS_TDM_VERS)
+        if self.COMMENT is not None:
+            TDMAddCOMMENT(builder, COMMENT)
+        if self.CREATION_DATE is not None:
+            TDMAddCREATION_DATE(builder, CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            TDMAddORIGINATOR(builder, ORIGINATOR)
+        if self.META_START is not None:
+            TDMAddMETA_START(builder, META_START)
+        if self.TIME_SYSTEM is not None:
+            TDMAddTIME_SYSTEM(builder, TIME_SYSTEM)
+        if self.START_TIME is not None:
+            TDMAddSTART_TIME(builder, START_TIME)
+        if self.STOP_TIME is not None:
+            TDMAddSTOP_TIME(builder, STOP_TIME)
+        if self.PARTICIPANT_1 is not None:
+            TDMAddPARTICIPANT_1(builder, PARTICIPANT_1)
+        if self.PARTICIPANT_2 is not None:
+            TDMAddPARTICIPANT_2(builder, PARTICIPANT_2)
+        if self.PARTICIPANT_3 is not None:
+            TDMAddPARTICIPANT_3(builder, PARTICIPANT_3)
+        if self.PARTICIPANT_4 is not None:
+            TDMAddPARTICIPANT_4(builder, PARTICIPANT_4)
+        if self.PARTICIPANT_5 is not None:
+            TDMAddPARTICIPANT_5(builder, PARTICIPANT_5)
+        if self.MODE is not None:
+            TDMAddMODE(builder, MODE)
+        TDMAddPATH_1(builder, self.PATH_1)
+        TDMAddPATH_2(builder, self.PATH_2)
+        if self.TRANSMIT_BAND is not None:
+            TDMAddTRANSMIT_BAND(builder, TRANSMIT_BAND)
+        if self.RECEIVE_BAND is not None:
+            TDMAddRECEIVE_BAND(builder, RECEIVE_BAND)
+        TDMAddINTEGRATION_INTERVAL(builder, self.INTEGRATION_INTERVAL)
+        if self.INTEGRATION_REF is not None:
+            TDMAddINTEGRATION_REF(builder, INTEGRATION_REF)
+        TDMAddRECEIVE_DELAY_2(builder, self.RECEIVE_DELAY_2)
+        TDMAddRECEIVE_DELAY_3(builder, self.RECEIVE_DELAY_3)
+        if self.DATA_QUALITY is not None:
+            TDMAddDATA_QUALITY(builder, DATA_QUALITY)
+        if self.META_STOP is not None:
+            TDMAddMETA_STOP(builder, META_STOP)
+        if self.DATA_START is not None:
+            TDMAddDATA_START(builder, DATA_START)
+        TDMAddTRANSMIT_FREQ_1(builder, self.TRANSMIT_FREQ_1)
+        if self.RECEIVE_FREQ is not None:
+            TDMAddRECEIVE_FREQ(builder, RECEIVE_FREQ)
+        if self.DATA_STOP is not None:
+            TDMAddDATA_STOP(builder, DATA_STOP)
+        if self.TIMETAG_REF is not None:
+            TDMAddTIMETAG_REF(builder, TIMETAG_REF)
+        if self.ANGLE_TYPE is not None:
+            TDMAddANGLE_TYPE(builder, ANGLE_TYPE)
+        if self.ANGLE_1 is not None:
+            TDMAddANGLE_1(builder, ANGLE_1)
+        if self.ANGLE_2 is not None:
+            TDMAddANGLE_2(builder, ANGLE_2)
+        TDMAddANGLE_UNCERTAINTY_1(builder, self.ANGLE_UNCERTAINTY_1)
+        TDMAddANGLE_UNCERTAINTY_2(builder, self.ANGLE_UNCERTAINTY_2)
+        TDMAddRANGE_RATE(builder, self.RANGE_RATE)
+        TDMAddRANGE_UNCERTAINTY(builder, self.RANGE_UNCERTAINTY)
+        if self.RANGE_MODE is not None:
+            TDMAddRANGE_MODE(builder, RANGE_MODE)
+        TDMAddRANGE_MODULUS(builder, self.RANGE_MODULUS)
+        TDMAddCORRECTION_ANGLE_1(builder, self.CORRECTION_ANGLE_1)
+        TDMAddCORRECTION_ANGLE_2(builder, self.CORRECTION_ANGLE_2)
+        if self.CORRECTIONS_APPLIED is not None:
+            TDMAddCORRECTIONS_APPLIED(builder, CORRECTIONS_APPLIED)
+        if self.TROPO_DRY is not None:
+            TDMAddTROPO_DRY(builder, TROPO_DRY)
+        if self.TROPO_WET is not None:
+            TDMAddTROPO_WET(builder, TROPO_WET)
+        if self.STEC is not None:
+            TDMAddSTEC(builder, STEC)
+        if self.PRESSURE is not None:
+            TDMAddPRESSURE(builder, PRESSURE)
+        if self.RHUMIDITY is not None:
+            TDMAddRHUMIDITY(builder, RHUMIDITY)
+        if self.TEMPERATURE is not None:
+            TDMAddTEMPERATURE(builder, TEMPERATURE)
+        if self.CLOCK_BIAS is not None:
+            TDMAddCLOCK_BIAS(builder, CLOCK_BIAS)
+        if self.CLOCK_DRIFT is not None:
+            TDMAddCLOCK_DRIFT(builder, CLOCK_DRIFT)
+        TDM = TDMEnd(builder)
+        return TDM