spacedatastandards.org 1.73.0__py3-none-any.whl

LDM/LDM.py

@@ -0,0 +1,985 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Launch Data Message
+class LDM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = LDM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsLDM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def LDMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4C\x44\x4D", size_prefixed=size_prefixed)
+
+    # LDM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Launch Site Information
+    # LDM
+    def SITE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from SIT import SIT
+            obj = SIT()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Azimuth at Launch (in Degrees)
+    # LDM
+    def AZIMUTH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # References for Launch Data
+    # LDM
+    def REFERENCES(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
+
+    # Launching Agency Name
+    # LDM
+    def AGENCY_NAME(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
+
+    # Points of Contact for Launch
+    # LDM
+    def POINTS_OF_CONTACT(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from EPM import EPM
+            obj = EPM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # LDM
+    def POINTS_OF_CONTACTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def POINTS_OF_CONTACTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Operations Points of Contact for Launch
+    # LDM
+    def OPERATIONS_POINTS_OF_CONTACT(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from EPM import EPM
+            obj = EPM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # LDM
+    def OPERATIONS_POINTS_OF_CONTACTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def OPERATIONS_POINTS_OF_CONTACTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Net Launch Time (UTC Format)
+    # LDM
+    def NET(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
+
+    # Rocket Configuration Details
+    # LDM
+    def ROCKET_CONFIGURATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ROC import ROC
+            obj = ROC()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Mission Name
+    # LDM
+    def MISSION_NAME(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
+
+    # Description of the Mission
+    # LDM
+    def MISSION_DESCRIPTION(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
+
+    # Type of the Mission (e.g., Test Flight, Satellite Deployment)
+    # LDM
+    def MISSION_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Target Orbit Type (e.g., LEO, GEO)
+    # LDM
+    def ORBIT_TYPE(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
+
+    # Weather and Environmental Conditions at Launch
+    # LDM
+    def WEATHER_CONDITIONS(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
+
+    # Launch Outcome and Status (e.g., Successful, Failed)
+    # LDM
+    def LAUNCH_STATUS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Webcast URL for the Launch
+    # LDM
+    def WEBCAST_URL(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
+
+    # Media Links Related to the Launch
+    # LDM
+    def MEDIA_LINKS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def MEDIA_LINKSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def MEDIA_LINKSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        return o == 0
+
+    # Earliest Possible Launch Times
+    # LDM
+    def EARLIEST_LAUNCH_TIMES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def EARLIEST_LAUNCH_TIMESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def EARLIEST_LAUNCH_TIMESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+    # Latest Possible Launch Times
+    # LDM
+    def LATEST_LAUNCH_TIMES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def LATEST_LAUNCH_TIMESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def LATEST_LAUNCH_TIMESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        return o == 0
+
+    # Launch Collision Avoidance Information
+    # LDM
+    def LCOLA_WINDOW_CLOSURES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def LCOLA_WINDOW_CLOSURESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def LCOLA_WINDOW_CLOSURESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        return o == 0
+
+    # Payload Information (Catalog Entities)
+    # LDM
+    def OBJECTS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from CAT import CAT
+            obj = CAT()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # LDM
+    def OBJECTSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def OBJECTSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        return o == 0
+
+    # Tracking and Collision Avoidance Requirements
+    # LDM
+    def TRACKING_REQUIREMENTS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def TRACKING_REQUIREMENTSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def TRACKING_REQUIREMENTSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        return o == 0
+
+    # Duration of Collision Avoidance Screen (in Seconds)
+    # LDM
+    def COLA_SCREEN_DURATION(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
+
+    # Probability of Collision Threshold (Percentage)
+    # LDM
+    def PROBABILITY_OF_COLLISION_THRESHOLD(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
+
+    # Number of Required Collision Avoidance Runs
+    # LDM
+    def COLA_RUNS_REQUIRED(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
+
+    # Points of Contact for Collision Avoidance
+    # LDM
+    def COLA_POINTS_OF_CONTACT(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from EPM import EPM
+            obj = EPM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # LDM
+    def COLA_POINTS_OF_CONTACTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def COLA_POINTS_OF_CONTACTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        return o == 0
+
+    # Orbital Parameters of the Launch
+    # LDM
+    def ORBITAL_PARAMETERS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # LDM
+    def ORBITAL_PARAMETERSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def ORBITAL_PARAMETERSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        return o == 0
+
+    # Burn Out Vectors for the Launch
+    # LDM
+    def BURN_OUT_VECTORS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from BOV import BOV
+            obj = BOV()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # LDM
+    def BURN_OUT_VECTORSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # LDM
+    def BURN_OUT_VECTORSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        return o == 0
+
+def LDMStart(builder):
+    builder.StartObject(27)
+
+def Start(builder):
+    LDMStart(builder)
+
+def LDMAddSITE(builder, SITE):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(SITE), 0)
+
+def AddSITE(builder, SITE):
+    LDMAddSITE(builder, SITE)
+
+def LDMAddAZIMUTH(builder, AZIMUTH):
+    builder.PrependFloat32Slot(1, AZIMUTH, 0.0)
+
+def AddAZIMUTH(builder, AZIMUTH):
+    LDMAddAZIMUTH(builder, AZIMUTH)
+
+def LDMAddREFERENCES(builder, REFERENCES):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(REFERENCES), 0)
+
+def AddREFERENCES(builder, REFERENCES):
+    LDMAddREFERENCES(builder, REFERENCES)
+
+def LDMAddAGENCY_NAME(builder, AGENCY_NAME):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(AGENCY_NAME), 0)
+
+def AddAGENCY_NAME(builder, AGENCY_NAME):
+    LDMAddAGENCY_NAME(builder, AGENCY_NAME)
+
+def LDMAddPOINTS_OF_CONTACT(builder, POINTS_OF_CONTACT):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(POINTS_OF_CONTACT), 0)
+
+def AddPOINTS_OF_CONTACT(builder, POINTS_OF_CONTACT):
+    LDMAddPOINTS_OF_CONTACT(builder, POINTS_OF_CONTACT)
+
+def LDMStartPOINTS_OF_CONTACTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartPOINTS_OF_CONTACTVector(builder, numElems):
+    return LDMStartPOINTS_OF_CONTACTVector(builder, numElems)
+
+def LDMAddOPERATIONS_POINTS_OF_CONTACT(builder, OPERATIONS_POINTS_OF_CONTACT):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(OPERATIONS_POINTS_OF_CONTACT), 0)
+
+def AddOPERATIONS_POINTS_OF_CONTACT(builder, OPERATIONS_POINTS_OF_CONTACT):
+    LDMAddOPERATIONS_POINTS_OF_CONTACT(builder, OPERATIONS_POINTS_OF_CONTACT)
+
+def LDMStartOPERATIONS_POINTS_OF_CONTACTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartOPERATIONS_POINTS_OF_CONTACTVector(builder, numElems):
+    return LDMStartOPERATIONS_POINTS_OF_CONTACTVector(builder, numElems)
+
+def LDMAddNET(builder, NET):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(NET), 0)
+
+def AddNET(builder, NET):
+    LDMAddNET(builder, NET)
+
+def LDMAddROCKET_CONFIGURATION(builder, ROCKET_CONFIGURATION):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(ROCKET_CONFIGURATION), 0)
+
+def AddROCKET_CONFIGURATION(builder, ROCKET_CONFIGURATION):
+    LDMAddROCKET_CONFIGURATION(builder, ROCKET_CONFIGURATION)
+
+def LDMAddMISSION_NAME(builder, MISSION_NAME):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(MISSION_NAME), 0)
+
+def AddMISSION_NAME(builder, MISSION_NAME):
+    LDMAddMISSION_NAME(builder, MISSION_NAME)
+
+def LDMAddMISSION_DESCRIPTION(builder, MISSION_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(MISSION_DESCRIPTION), 0)
+
+def AddMISSION_DESCRIPTION(builder, MISSION_DESCRIPTION):
+    LDMAddMISSION_DESCRIPTION(builder, MISSION_DESCRIPTION)
+
+def LDMAddMISSION_TYPE(builder, MISSION_TYPE):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(MISSION_TYPE), 0)
+
+def AddMISSION_TYPE(builder, MISSION_TYPE):
+    LDMAddMISSION_TYPE(builder, MISSION_TYPE)
+
+def LDMAddORBIT_TYPE(builder, ORBIT_TYPE):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(ORBIT_TYPE), 0)
+
+def AddORBIT_TYPE(builder, ORBIT_TYPE):
+    LDMAddORBIT_TYPE(builder, ORBIT_TYPE)
+
+def LDMAddWEATHER_CONDITIONS(builder, WEATHER_CONDITIONS):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(WEATHER_CONDITIONS), 0)
+
+def AddWEATHER_CONDITIONS(builder, WEATHER_CONDITIONS):
+    LDMAddWEATHER_CONDITIONS(builder, WEATHER_CONDITIONS)
+
+def LDMAddLAUNCH_STATUS(builder, LAUNCH_STATUS):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(LAUNCH_STATUS), 0)
+
+def AddLAUNCH_STATUS(builder, LAUNCH_STATUS):
+    LDMAddLAUNCH_STATUS(builder, LAUNCH_STATUS)
+
+def LDMAddWEBCAST_URL(builder, WEBCAST_URL):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(WEBCAST_URL), 0)
+
+def AddWEBCAST_URL(builder, WEBCAST_URL):
+    LDMAddWEBCAST_URL(builder, WEBCAST_URL)
+
+def LDMAddMEDIA_LINKS(builder, MEDIA_LINKS):
+    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(MEDIA_LINKS), 0)
+
+def AddMEDIA_LINKS(builder, MEDIA_LINKS):
+    LDMAddMEDIA_LINKS(builder, MEDIA_LINKS)
+
+def LDMStartMEDIA_LINKSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartMEDIA_LINKSVector(builder, numElems):
+    return LDMStartMEDIA_LINKSVector(builder, numElems)
+
+def LDMAddEARLIEST_LAUNCH_TIMES(builder, EARLIEST_LAUNCH_TIMES):
+    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(EARLIEST_LAUNCH_TIMES), 0)
+
+def AddEARLIEST_LAUNCH_TIMES(builder, EARLIEST_LAUNCH_TIMES):
+    LDMAddEARLIEST_LAUNCH_TIMES(builder, EARLIEST_LAUNCH_TIMES)
+
+def LDMStartEARLIEST_LAUNCH_TIMESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartEARLIEST_LAUNCH_TIMESVector(builder, numElems):
+    return LDMStartEARLIEST_LAUNCH_TIMESVector(builder, numElems)
+
+def LDMAddLATEST_LAUNCH_TIMES(builder, LATEST_LAUNCH_TIMES):
+    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(LATEST_LAUNCH_TIMES), 0)
+
+def AddLATEST_LAUNCH_TIMES(builder, LATEST_LAUNCH_TIMES):
+    LDMAddLATEST_LAUNCH_TIMES(builder, LATEST_LAUNCH_TIMES)
+
+def LDMStartLATEST_LAUNCH_TIMESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartLATEST_LAUNCH_TIMESVector(builder, numElems):
+    return LDMStartLATEST_LAUNCH_TIMESVector(builder, numElems)
+
+def LDMAddLCOLA_WINDOW_CLOSURES(builder, LCOLA_WINDOW_CLOSURES):
+    builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(LCOLA_WINDOW_CLOSURES), 0)
+
+def AddLCOLA_WINDOW_CLOSURES(builder, LCOLA_WINDOW_CLOSURES):
+    LDMAddLCOLA_WINDOW_CLOSURES(builder, LCOLA_WINDOW_CLOSURES)
+
+def LDMStartLCOLA_WINDOW_CLOSURESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartLCOLA_WINDOW_CLOSURESVector(builder, numElems):
+    return LDMStartLCOLA_WINDOW_CLOSURESVector(builder, numElems)
+
+def LDMAddOBJECTS(builder, OBJECTS):
+    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECTS), 0)
+
+def AddOBJECTS(builder, OBJECTS):
+    LDMAddOBJECTS(builder, OBJECTS)
+
+def LDMStartOBJECTSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartOBJECTSVector(builder, numElems):
+    return LDMStartOBJECTSVector(builder, numElems)
+
+def LDMAddTRACKING_REQUIREMENTS(builder, TRACKING_REQUIREMENTS):
+    builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(TRACKING_REQUIREMENTS), 0)
+
+def AddTRACKING_REQUIREMENTS(builder, TRACKING_REQUIREMENTS):
+    LDMAddTRACKING_REQUIREMENTS(builder, TRACKING_REQUIREMENTS)
+
+def LDMStartTRACKING_REQUIREMENTSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartTRACKING_REQUIREMENTSVector(builder, numElems):
+    return LDMStartTRACKING_REQUIREMENTSVector(builder, numElems)
+
+def LDMAddCOLA_SCREEN_DURATION(builder, COLA_SCREEN_DURATION):
+    builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(COLA_SCREEN_DURATION), 0)
+
+def AddCOLA_SCREEN_DURATION(builder, COLA_SCREEN_DURATION):
+    LDMAddCOLA_SCREEN_DURATION(builder, COLA_SCREEN_DURATION)
+
+def LDMAddPROBABILITY_OF_COLLISION_THRESHOLD(builder, PROBABILITY_OF_COLLISION_THRESHOLD):
+    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(PROBABILITY_OF_COLLISION_THRESHOLD), 0)
+
+def AddPROBABILITY_OF_COLLISION_THRESHOLD(builder, PROBABILITY_OF_COLLISION_THRESHOLD):
+    LDMAddPROBABILITY_OF_COLLISION_THRESHOLD(builder, PROBABILITY_OF_COLLISION_THRESHOLD)
+
+def LDMAddCOLA_RUNS_REQUIRED(builder, COLA_RUNS_REQUIRED):
+    builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(COLA_RUNS_REQUIRED), 0)
+
+def AddCOLA_RUNS_REQUIRED(builder, COLA_RUNS_REQUIRED):
+    LDMAddCOLA_RUNS_REQUIRED(builder, COLA_RUNS_REQUIRED)
+
+def LDMAddCOLA_POINTS_OF_CONTACT(builder, COLA_POINTS_OF_CONTACT):
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(COLA_POINTS_OF_CONTACT), 0)
+
+def AddCOLA_POINTS_OF_CONTACT(builder, COLA_POINTS_OF_CONTACT):
+    LDMAddCOLA_POINTS_OF_CONTACT(builder, COLA_POINTS_OF_CONTACT)
+
+def LDMStartCOLA_POINTS_OF_CONTACTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCOLA_POINTS_OF_CONTACTVector(builder, numElems):
+    return LDMStartCOLA_POINTS_OF_CONTACTVector(builder, numElems)
+
+def LDMAddORBITAL_PARAMETERS(builder, ORBITAL_PARAMETERS):
+    builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(ORBITAL_PARAMETERS), 0)
+
+def AddORBITAL_PARAMETERS(builder, ORBITAL_PARAMETERS):
+    LDMAddORBITAL_PARAMETERS(builder, ORBITAL_PARAMETERS)
+
+def LDMStartORBITAL_PARAMETERSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartORBITAL_PARAMETERSVector(builder, numElems):
+    return LDMStartORBITAL_PARAMETERSVector(builder, numElems)
+
+def LDMAddBURN_OUT_VECTORS(builder, BURN_OUT_VECTORS):
+    builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(BURN_OUT_VECTORS), 0)
+
+def AddBURN_OUT_VECTORS(builder, BURN_OUT_VECTORS):
+    LDMAddBURN_OUT_VECTORS(builder, BURN_OUT_VECTORS)
+
+def LDMStartBURN_OUT_VECTORSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBURN_OUT_VECTORSVector(builder, numElems):
+    return LDMStartBURN_OUT_VECTORSVector(builder, numElems)
+
+def LDMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return LDMEnd(builder)
+
+import BOV
+import CAT
+import EPM
+import ROC
+import SIT
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class LDMT(object):
+
+    # LDMT
+    def __init__(self):
+        self.SITE = None  # type: Optional[SIT.SITT]
+        self.AZIMUTH = 0.0  # type: float
+        self.REFERENCES = None  # type: str
+        self.AGENCY_NAME = None  # type: str
+        self.POINTS_OF_CONTACT = None  # type: List[EPM.EPMT]
+        self.OPERATIONS_POINTS_OF_CONTACT = None  # type: List[EPM.EPMT]
+        self.NET = None  # type: str
+        self.ROCKET_CONFIGURATION = None  # type: Optional[ROC.ROCT]
+        self.MISSION_NAME = None  # type: str
+        self.MISSION_DESCRIPTION = None  # type: str
+        self.MISSION_TYPE = None  # type: str
+        self.ORBIT_TYPE = None  # type: str
+        self.WEATHER_CONDITIONS = None  # type: str
+        self.LAUNCH_STATUS = None  # type: str
+        self.WEBCAST_URL = None  # type: str
+        self.MEDIA_LINKS = None  # type: List[str]
+        self.EARLIEST_LAUNCH_TIMES = None  # type: List[str]
+        self.LATEST_LAUNCH_TIMES = None  # type: List[str]
+        self.LCOLA_WINDOW_CLOSURES = None  # type: List[str]
+        self.OBJECTS = None  # type: List[CAT.CATT]
+        self.TRACKING_REQUIREMENTS = None  # type: List[str]
+        self.COLA_SCREEN_DURATION = None  # type: str
+        self.PROBABILITY_OF_COLLISION_THRESHOLD = None  # type: str
+        self.COLA_RUNS_REQUIRED = None  # type: str
+        self.COLA_POINTS_OF_CONTACT = None  # type: List[EPM.EPMT]
+        self.ORBITAL_PARAMETERS = None  # type: List[str]
+        self.BURN_OUT_VECTORS = None  # type: List[BOV.BOVT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        LDM = LDM()
+        LDM.Init(buf, pos)
+        return cls.InitFromObj(LDM)
+
+    @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, LDM):
+        x = LDMT()
+        x._UnPack(LDM)
+        return x
+
+    # LDMT
+    def _UnPack(self, LDM):
+        if LDM is None:
+            return
+        if LDM.SITE() is not None:
+            self.SITE = SIT.SITT.InitFromObj(LDM.SITE())
+        self.AZIMUTH = LDM.AZIMUTH()
+        self.REFERENCES = LDM.REFERENCES()
+        self.AGENCY_NAME = LDM.AGENCY_NAME()
+        if not LDM.POINTS_OF_CONTACTIsNone():
+            self.POINTS_OF_CONTACT = []
+            for i in range(LDM.POINTS_OF_CONTACTLength()):
+                if LDM.POINTS_OF_CONTACT(i) is None:
+                    self.POINTS_OF_CONTACT.append(None)
+                else:
+                    ePM_ = EPM.EPMT.InitFromObj(LDM.POINTS_OF_CONTACT(i))
+                    self.POINTS_OF_CONTACT.append(ePM_)
+        if not LDM.OPERATIONS_POINTS_OF_CONTACTIsNone():
+            self.OPERATIONS_POINTS_OF_CONTACT = []
+            for i in range(LDM.OPERATIONS_POINTS_OF_CONTACTLength()):
+                if LDM.OPERATIONS_POINTS_OF_CONTACT(i) is None:
+                    self.OPERATIONS_POINTS_OF_CONTACT.append(None)
+                else:
+                    ePM_ = EPM.EPMT.InitFromObj(LDM.OPERATIONS_POINTS_OF_CONTACT(i))
+                    self.OPERATIONS_POINTS_OF_CONTACT.append(ePM_)
+        self.NET = LDM.NET()
+        if LDM.ROCKET_CONFIGURATION() is not None:
+            self.ROCKET_CONFIGURATION = ROC.ROCT.InitFromObj(LDM.ROCKET_CONFIGURATION())
+        self.MISSION_NAME = LDM.MISSION_NAME()
+        self.MISSION_DESCRIPTION = LDM.MISSION_DESCRIPTION()
+        self.MISSION_TYPE = LDM.MISSION_TYPE()
+        self.ORBIT_TYPE = LDM.ORBIT_TYPE()
+        self.WEATHER_CONDITIONS = LDM.WEATHER_CONDITIONS()
+        self.LAUNCH_STATUS = LDM.LAUNCH_STATUS()
+        self.WEBCAST_URL = LDM.WEBCAST_URL()
+        if not LDM.MEDIA_LINKSIsNone():
+            self.MEDIA_LINKS = []
+            for i in range(LDM.MEDIA_LINKSLength()):
+                self.MEDIA_LINKS.append(LDM.MEDIA_LINKS(i))
+        if not LDM.EARLIEST_LAUNCH_TIMESIsNone():
+            self.EARLIEST_LAUNCH_TIMES = []
+            for i in range(LDM.EARLIEST_LAUNCH_TIMESLength()):
+                self.EARLIEST_LAUNCH_TIMES.append(LDM.EARLIEST_LAUNCH_TIMES(i))
+        if not LDM.LATEST_LAUNCH_TIMESIsNone():
+            self.LATEST_LAUNCH_TIMES = []
+            for i in range(LDM.LATEST_LAUNCH_TIMESLength()):
+                self.LATEST_LAUNCH_TIMES.append(LDM.LATEST_LAUNCH_TIMES(i))
+        if not LDM.LCOLA_WINDOW_CLOSURESIsNone():
+            self.LCOLA_WINDOW_CLOSURES = []
+            for i in range(LDM.LCOLA_WINDOW_CLOSURESLength()):
+                self.LCOLA_WINDOW_CLOSURES.append(LDM.LCOLA_WINDOW_CLOSURES(i))
+        if not LDM.OBJECTSIsNone():
+            self.OBJECTS = []
+            for i in range(LDM.OBJECTSLength()):
+                if LDM.OBJECTS(i) is None:
+                    self.OBJECTS.append(None)
+                else:
+                    cAT_ = CAT.CATT.InitFromObj(LDM.OBJECTS(i))
+                    self.OBJECTS.append(cAT_)
+        if not LDM.TRACKING_REQUIREMENTSIsNone():
+            self.TRACKING_REQUIREMENTS = []
+            for i in range(LDM.TRACKING_REQUIREMENTSLength()):
+                self.TRACKING_REQUIREMENTS.append(LDM.TRACKING_REQUIREMENTS(i))
+        self.COLA_SCREEN_DURATION = LDM.COLA_SCREEN_DURATION()
+        self.PROBABILITY_OF_COLLISION_THRESHOLD = LDM.PROBABILITY_OF_COLLISION_THRESHOLD()
+        self.COLA_RUNS_REQUIRED = LDM.COLA_RUNS_REQUIRED()
+        if not LDM.COLA_POINTS_OF_CONTACTIsNone():
+            self.COLA_POINTS_OF_CONTACT = []
+            for i in range(LDM.COLA_POINTS_OF_CONTACTLength()):
+                if LDM.COLA_POINTS_OF_CONTACT(i) is None:
+                    self.COLA_POINTS_OF_CONTACT.append(None)
+                else:
+                    ePM_ = EPM.EPMT.InitFromObj(LDM.COLA_POINTS_OF_CONTACT(i))
+                    self.COLA_POINTS_OF_CONTACT.append(ePM_)
+        if not LDM.ORBITAL_PARAMETERSIsNone():
+            self.ORBITAL_PARAMETERS = []
+            for i in range(LDM.ORBITAL_PARAMETERSLength()):
+                self.ORBITAL_PARAMETERS.append(LDM.ORBITAL_PARAMETERS(i))
+        if not LDM.BURN_OUT_VECTORSIsNone():
+            self.BURN_OUT_VECTORS = []
+            for i in range(LDM.BURN_OUT_VECTORSLength()):
+                if LDM.BURN_OUT_VECTORS(i) is None:
+                    self.BURN_OUT_VECTORS.append(None)
+                else:
+                    bOV_ = BOV.BOVT.InitFromObj(LDM.BURN_OUT_VECTORS(i))
+                    self.BURN_OUT_VECTORS.append(bOV_)
+
+    # LDMT
+    def Pack(self, builder):
+        if self.SITE is not None:
+            SITE = self.SITE.Pack(builder)
+        if self.REFERENCES is not None:
+            REFERENCES = builder.CreateString(self.REFERENCES)
+        if self.AGENCY_NAME is not None:
+            AGENCY_NAME = builder.CreateString(self.AGENCY_NAME)
+        if self.POINTS_OF_CONTACT is not None:
+            POINTS_OF_CONTACTlist = []
+            for i in range(len(self.POINTS_OF_CONTACT)):
+                POINTS_OF_CONTACTlist.append(self.POINTS_OF_CONTACT[i].Pack(builder))
+            LDMStartPOINTS_OF_CONTACTVector(builder, len(self.POINTS_OF_CONTACT))
+            for i in reversed(range(len(self.POINTS_OF_CONTACT))):
+                builder.PrependUOffsetTRelative(POINTS_OF_CONTACTlist[i])
+            POINTS_OF_CONTACT = builder.EndVector()
+        if self.OPERATIONS_POINTS_OF_CONTACT is not None:
+            OPERATIONS_POINTS_OF_CONTACTlist = []
+            for i in range(len(self.OPERATIONS_POINTS_OF_CONTACT)):
+                OPERATIONS_POINTS_OF_CONTACTlist.append(self.OPERATIONS_POINTS_OF_CONTACT[i].Pack(builder))
+            LDMStartOPERATIONS_POINTS_OF_CONTACTVector(builder, len(self.OPERATIONS_POINTS_OF_CONTACT))
+            for i in reversed(range(len(self.OPERATIONS_POINTS_OF_CONTACT))):
+                builder.PrependUOffsetTRelative(OPERATIONS_POINTS_OF_CONTACTlist[i])
+            OPERATIONS_POINTS_OF_CONTACT = builder.EndVector()
+        if self.NET is not None:
+            NET = builder.CreateString(self.NET)
+        if self.ROCKET_CONFIGURATION is not None:
+            ROCKET_CONFIGURATION = self.ROCKET_CONFIGURATION.Pack(builder)
+        if self.MISSION_NAME is not None:
+            MISSION_NAME = builder.CreateString(self.MISSION_NAME)
+        if self.MISSION_DESCRIPTION is not None:
+            MISSION_DESCRIPTION = builder.CreateString(self.MISSION_DESCRIPTION)
+        if self.MISSION_TYPE is not None:
+            MISSION_TYPE = builder.CreateString(self.MISSION_TYPE)
+        if self.ORBIT_TYPE is not None:
+            ORBIT_TYPE = builder.CreateString(self.ORBIT_TYPE)
+        if self.WEATHER_CONDITIONS is not None:
+            WEATHER_CONDITIONS = builder.CreateString(self.WEATHER_CONDITIONS)
+        if self.LAUNCH_STATUS is not None:
+            LAUNCH_STATUS = builder.CreateString(self.LAUNCH_STATUS)
+        if self.WEBCAST_URL is not None:
+            WEBCAST_URL = builder.CreateString(self.WEBCAST_URL)
+        if self.MEDIA_LINKS is not None:
+            MEDIA_LINKSlist = []
+            for i in range(len(self.MEDIA_LINKS)):
+                MEDIA_LINKSlist.append(builder.CreateString(self.MEDIA_LINKS[i]))
+            LDMStartMEDIA_LINKSVector(builder, len(self.MEDIA_LINKS))
+            for i in reversed(range(len(self.MEDIA_LINKS))):
+                builder.PrependUOffsetTRelative(MEDIA_LINKSlist[i])
+            MEDIA_LINKS = builder.EndVector()
+        if self.EARLIEST_LAUNCH_TIMES is not None:
+            EARLIEST_LAUNCH_TIMESlist = []
+            for i in range(len(self.EARLIEST_LAUNCH_TIMES)):
+                EARLIEST_LAUNCH_TIMESlist.append(builder.CreateString(self.EARLIEST_LAUNCH_TIMES[i]))
+            LDMStartEARLIEST_LAUNCH_TIMESVector(builder, len(self.EARLIEST_LAUNCH_TIMES))
+            for i in reversed(range(len(self.EARLIEST_LAUNCH_TIMES))):
+                builder.PrependUOffsetTRelative(EARLIEST_LAUNCH_TIMESlist[i])
+            EARLIEST_LAUNCH_TIMES = builder.EndVector()
+        if self.LATEST_LAUNCH_TIMES is not None:
+            LATEST_LAUNCH_TIMESlist = []
+            for i in range(len(self.LATEST_LAUNCH_TIMES)):
+                LATEST_LAUNCH_TIMESlist.append(builder.CreateString(self.LATEST_LAUNCH_TIMES[i]))
+            LDMStartLATEST_LAUNCH_TIMESVector(builder, len(self.LATEST_LAUNCH_TIMES))
+            for i in reversed(range(len(self.LATEST_LAUNCH_TIMES))):
+                builder.PrependUOffsetTRelative(LATEST_LAUNCH_TIMESlist[i])
+            LATEST_LAUNCH_TIMES = builder.EndVector()
+        if self.LCOLA_WINDOW_CLOSURES is not None:
+            LCOLA_WINDOW_CLOSURESlist = []
+            for i in range(len(self.LCOLA_WINDOW_CLOSURES)):
+                LCOLA_WINDOW_CLOSURESlist.append(builder.CreateString(self.LCOLA_WINDOW_CLOSURES[i]))
+            LDMStartLCOLA_WINDOW_CLOSURESVector(builder, len(self.LCOLA_WINDOW_CLOSURES))
+            for i in reversed(range(len(self.LCOLA_WINDOW_CLOSURES))):
+                builder.PrependUOffsetTRelative(LCOLA_WINDOW_CLOSURESlist[i])
+            LCOLA_WINDOW_CLOSURES = builder.EndVector()
+        if self.OBJECTS is not None:
+            OBJECTSlist = []
+            for i in range(len(self.OBJECTS)):
+                OBJECTSlist.append(self.OBJECTS[i].Pack(builder))
+            LDMStartOBJECTSVector(builder, len(self.OBJECTS))
+            for i in reversed(range(len(self.OBJECTS))):
+                builder.PrependUOffsetTRelative(OBJECTSlist[i])
+            OBJECTS = builder.EndVector()
+        if self.TRACKING_REQUIREMENTS is not None:
+            TRACKING_REQUIREMENTSlist = []
+            for i in range(len(self.TRACKING_REQUIREMENTS)):
+                TRACKING_REQUIREMENTSlist.append(builder.CreateString(self.TRACKING_REQUIREMENTS[i]))
+            LDMStartTRACKING_REQUIREMENTSVector(builder, len(self.TRACKING_REQUIREMENTS))
+            for i in reversed(range(len(self.TRACKING_REQUIREMENTS))):
+                builder.PrependUOffsetTRelative(TRACKING_REQUIREMENTSlist[i])
+            TRACKING_REQUIREMENTS = builder.EndVector()
+        if self.COLA_SCREEN_DURATION is not None:
+            COLA_SCREEN_DURATION = builder.CreateString(self.COLA_SCREEN_DURATION)
+        if self.PROBABILITY_OF_COLLISION_THRESHOLD is not None:
+            PROBABILITY_OF_COLLISION_THRESHOLD = builder.CreateString(self.PROBABILITY_OF_COLLISION_THRESHOLD)
+        if self.COLA_RUNS_REQUIRED is not None:
+            COLA_RUNS_REQUIRED = builder.CreateString(self.COLA_RUNS_REQUIRED)
+        if self.COLA_POINTS_OF_CONTACT is not None:
+            COLA_POINTS_OF_CONTACTlist = []
+            for i in range(len(self.COLA_POINTS_OF_CONTACT)):
+                COLA_POINTS_OF_CONTACTlist.append(self.COLA_POINTS_OF_CONTACT[i].Pack(builder))
+            LDMStartCOLA_POINTS_OF_CONTACTVector(builder, len(self.COLA_POINTS_OF_CONTACT))
+            for i in reversed(range(len(self.COLA_POINTS_OF_CONTACT))):
+                builder.PrependUOffsetTRelative(COLA_POINTS_OF_CONTACTlist[i])
+            COLA_POINTS_OF_CONTACT = builder.EndVector()
+        if self.ORBITAL_PARAMETERS is not None:
+            ORBITAL_PARAMETERSlist = []
+            for i in range(len(self.ORBITAL_PARAMETERS)):
+                ORBITAL_PARAMETERSlist.append(builder.CreateString(self.ORBITAL_PARAMETERS[i]))
+            LDMStartORBITAL_PARAMETERSVector(builder, len(self.ORBITAL_PARAMETERS))
+            for i in reversed(range(len(self.ORBITAL_PARAMETERS))):
+                builder.PrependUOffsetTRelative(ORBITAL_PARAMETERSlist[i])
+            ORBITAL_PARAMETERS = builder.EndVector()
+        if self.BURN_OUT_VECTORS is not None:
+            BURN_OUT_VECTORSlist = []
+            for i in range(len(self.BURN_OUT_VECTORS)):
+                BURN_OUT_VECTORSlist.append(self.BURN_OUT_VECTORS[i].Pack(builder))
+            LDMStartBURN_OUT_VECTORSVector(builder, len(self.BURN_OUT_VECTORS))
+            for i in reversed(range(len(self.BURN_OUT_VECTORS))):
+                builder.PrependUOffsetTRelative(BURN_OUT_VECTORSlist[i])
+            BURN_OUT_VECTORS = builder.EndVector()
+        LDMStart(builder)
+        if self.SITE is not None:
+            LDMAddSITE(builder, SITE)
+        LDMAddAZIMUTH(builder, self.AZIMUTH)
+        if self.REFERENCES is not None:
+            LDMAddREFERENCES(builder, REFERENCES)
+        if self.AGENCY_NAME is not None:
+            LDMAddAGENCY_NAME(builder, AGENCY_NAME)
+        if self.POINTS_OF_CONTACT is not None:
+            LDMAddPOINTS_OF_CONTACT(builder, POINTS_OF_CONTACT)
+        if self.OPERATIONS_POINTS_OF_CONTACT is not None:
+            LDMAddOPERATIONS_POINTS_OF_CONTACT(builder, OPERATIONS_POINTS_OF_CONTACT)
+        if self.NET is not None:
+            LDMAddNET(builder, NET)
+        if self.ROCKET_CONFIGURATION is not None:
+            LDMAddROCKET_CONFIGURATION(builder, ROCKET_CONFIGURATION)
+        if self.MISSION_NAME is not None:
+            LDMAddMISSION_NAME(builder, MISSION_NAME)
+        if self.MISSION_DESCRIPTION is not None:
+            LDMAddMISSION_DESCRIPTION(builder, MISSION_DESCRIPTION)
+        if self.MISSION_TYPE is not None:
+            LDMAddMISSION_TYPE(builder, MISSION_TYPE)
+        if self.ORBIT_TYPE is not None:
+            LDMAddORBIT_TYPE(builder, ORBIT_TYPE)
+        if self.WEATHER_CONDITIONS is not None:
+            LDMAddWEATHER_CONDITIONS(builder, WEATHER_CONDITIONS)
+        if self.LAUNCH_STATUS is not None:
+            LDMAddLAUNCH_STATUS(builder, LAUNCH_STATUS)
+        if self.WEBCAST_URL is not None:
+            LDMAddWEBCAST_URL(builder, WEBCAST_URL)
+        if self.MEDIA_LINKS is not None:
+            LDMAddMEDIA_LINKS(builder, MEDIA_LINKS)
+        if self.EARLIEST_LAUNCH_TIMES is not None:
+            LDMAddEARLIEST_LAUNCH_TIMES(builder, EARLIEST_LAUNCH_TIMES)
+        if self.LATEST_LAUNCH_TIMES is not None:
+            LDMAddLATEST_LAUNCH_TIMES(builder, LATEST_LAUNCH_TIMES)
+        if self.LCOLA_WINDOW_CLOSURES is not None:
+            LDMAddLCOLA_WINDOW_CLOSURES(builder, LCOLA_WINDOW_CLOSURES)
+        if self.OBJECTS is not None:
+            LDMAddOBJECTS(builder, OBJECTS)
+        if self.TRACKING_REQUIREMENTS is not None:
+            LDMAddTRACKING_REQUIREMENTS(builder, TRACKING_REQUIREMENTS)
+        if self.COLA_SCREEN_DURATION is not None:
+            LDMAddCOLA_SCREEN_DURATION(builder, COLA_SCREEN_DURATION)
+        if self.PROBABILITY_OF_COLLISION_THRESHOLD is not None:
+            LDMAddPROBABILITY_OF_COLLISION_THRESHOLD(builder, PROBABILITY_OF_COLLISION_THRESHOLD)
+        if self.COLA_RUNS_REQUIRED is not None:
+            LDMAddCOLA_RUNS_REQUIRED(builder, COLA_RUNS_REQUIRED)
+        if self.COLA_POINTS_OF_CONTACT is not None:
+            LDMAddCOLA_POINTS_OF_CONTACT(builder, COLA_POINTS_OF_CONTACT)
+        if self.ORBITAL_PARAMETERS is not None:
+            LDMAddORBITAL_PARAMETERS(builder, ORBITAL_PARAMETERS)
+        if self.BURN_OUT_VECTORS is not None:
+            LDMAddBURN_OUT_VECTORS(builder, BURN_OUT_VECTORS)
+        LDM = LDMEnd(builder)
+        return LDM