spacedatastandards.org 1.73.0__py3-none-any.whl

CDM/CAT.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CAT.py does not declare any structs or enums

CDM/CDM.py

@@ -0,0 +1,646 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Conjunction Data Message
+class CDM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CDM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCDM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CDMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x43\x44\x4D", size_prefixed=size_prefixed)
+
+    # CDM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # The version of the CCSDS CDM standard used
+    # CDM
+    def CCSDS_CDM_VERS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The date the CDM message was created
+    # CDM
+    def CREATION_DATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # The originator of the CDM message
+    # CDM
+    def ORIGINATOR(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
+
+    # The intended recipient of the CDM message
+    # CDM
+    def MESSAGE_FOR(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
+
+    # A unique identifier for the CDM message
+    # CDM
+    def MESSAGE_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Time of closest approach
+    # CDM
+    def TCA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # The miss distance between the two objects
+    # CDM
+    def MISS_DISTANCE(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
+
+    # The relative speed between the two objects
+    # CDM
+    def RELATIVE_SPEED(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The relative position R component
+    # CDM
+    def RELATIVE_POSITION_R(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The relative position T component
+    # CDM
+    def RELATIVE_POSITION_T(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The relative position N component
+    # CDM
+    def RELATIVE_POSITION_N(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
+
+    # The relative velocity R component
+    # CDM
+    def RELATIVE_VELOCITY_R(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The relative velocity T component
+    # CDM
+    def RELATIVE_VELOCITY_T(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The relative velocity N component
+    # CDM
+    def RELATIVE_VELOCITY_N(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The start time of the screening period
+    # CDM
+    def START_SCREEN_PERIOD(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
+
+    # The end time of the screening period
+    # CDM
+    def STOP_SCREEN_PERIOD(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
+
+    # The reference frame for the screening volume
+    # CDM
+    def SCREEN_VOLUME_FRAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        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
+
+    # The shape of the screening volume
+    # CDM
+    def SCREEN_VOLUME_SHAPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # The X dimension of the screening volume
+    # CDM
+    def SCREEN_VOLUME_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The Y dimension of the screening volume
+    # CDM
+    def SCREEN_VOLUME_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The Z dimension of the screening volume
+    # CDM
+    def SCREEN_VOLUME_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The time the objects entered the screening volume
+    # CDM
+    def SCREEN_ENTRY_TIME(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
+
+    # The time the objects exited the screening volume
+    # CDM
+    def SCREEN_EXIT_TIME(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
+
+    # The probability of collision between the two objects
+    # CDM
+    def COLLISION_PROBABILITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # The method used to calculate the collision probability
+    # CDM
+    def COLLISION_PROBABILITY_METHOD(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
+
+    # The first object in the CDM message
+    # CDM
+    def OBJECT1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from CDMObject import CDMObject
+            obj = CDMObject()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # The second object in the CDM message
+    # CDM
+    def OBJECT2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from CDMObject import CDMObject
+            obj = CDMObject()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Data Source for the positional information for Object 1
+    # CDM
+    def OBJECT1_DATASOURCE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from PNM import PNM
+            obj = PNM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Data Source for the positional information for Object 2
+    # CDM
+    def OBJECT2_DATASOURCE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from PNM import PNM
+            obj = PNM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def CDMStart(builder):
+    builder.StartObject(29)
+
+def Start(builder):
+    CDMStart(builder)
+
+def CDMAddCCSDS_CDM_VERS(builder, CCSDS_CDM_VERS):
+    builder.PrependFloat64Slot(0, CCSDS_CDM_VERS, 0.0)
+
+def AddCCSDS_CDM_VERS(builder, CCSDS_CDM_VERS):
+    CDMAddCCSDS_CDM_VERS(builder, CCSDS_CDM_VERS)
+
+def CDMAddCREATION_DATE(builder, CREATION_DATE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CREATION_DATE), 0)
+
+def AddCREATION_DATE(builder, CREATION_DATE):
+    CDMAddCREATION_DATE(builder, CREATION_DATE)
+
+def CDMAddORIGINATOR(builder, ORIGINATOR):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(ORIGINATOR), 0)
+
+def AddORIGINATOR(builder, ORIGINATOR):
+    CDMAddORIGINATOR(builder, ORIGINATOR)
+
+def CDMAddMESSAGE_FOR(builder, MESSAGE_FOR):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(MESSAGE_FOR), 0)
+
+def AddMESSAGE_FOR(builder, MESSAGE_FOR):
+    CDMAddMESSAGE_FOR(builder, MESSAGE_FOR)
+
+def CDMAddMESSAGE_ID(builder, MESSAGE_ID):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(MESSAGE_ID), 0)
+
+def AddMESSAGE_ID(builder, MESSAGE_ID):
+    CDMAddMESSAGE_ID(builder, MESSAGE_ID)
+
+def CDMAddTCA(builder, TCA):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(TCA), 0)
+
+def AddTCA(builder, TCA):
+    CDMAddTCA(builder, TCA)
+
+def CDMAddMISS_DISTANCE(builder, MISS_DISTANCE):
+    builder.PrependFloat64Slot(6, MISS_DISTANCE, 0.0)
+
+def AddMISS_DISTANCE(builder, MISS_DISTANCE):
+    CDMAddMISS_DISTANCE(builder, MISS_DISTANCE)
+
+def CDMAddRELATIVE_SPEED(builder, RELATIVE_SPEED):
+    builder.PrependFloat64Slot(7, RELATIVE_SPEED, 0.0)
+
+def AddRELATIVE_SPEED(builder, RELATIVE_SPEED):
+    CDMAddRELATIVE_SPEED(builder, RELATIVE_SPEED)
+
+def CDMAddRELATIVE_POSITION_R(builder, RELATIVE_POSITION_R):
+    builder.PrependFloat64Slot(8, RELATIVE_POSITION_R, 0.0)
+
+def AddRELATIVE_POSITION_R(builder, RELATIVE_POSITION_R):
+    CDMAddRELATIVE_POSITION_R(builder, RELATIVE_POSITION_R)
+
+def CDMAddRELATIVE_POSITION_T(builder, RELATIVE_POSITION_T):
+    builder.PrependFloat64Slot(9, RELATIVE_POSITION_T, 0.0)
+
+def AddRELATIVE_POSITION_T(builder, RELATIVE_POSITION_T):
+    CDMAddRELATIVE_POSITION_T(builder, RELATIVE_POSITION_T)
+
+def CDMAddRELATIVE_POSITION_N(builder, RELATIVE_POSITION_N):
+    builder.PrependFloat64Slot(10, RELATIVE_POSITION_N, 0.0)
+
+def AddRELATIVE_POSITION_N(builder, RELATIVE_POSITION_N):
+    CDMAddRELATIVE_POSITION_N(builder, RELATIVE_POSITION_N)
+
+def CDMAddRELATIVE_VELOCITY_R(builder, RELATIVE_VELOCITY_R):
+    builder.PrependFloat64Slot(11, RELATIVE_VELOCITY_R, 0.0)
+
+def AddRELATIVE_VELOCITY_R(builder, RELATIVE_VELOCITY_R):
+    CDMAddRELATIVE_VELOCITY_R(builder, RELATIVE_VELOCITY_R)
+
+def CDMAddRELATIVE_VELOCITY_T(builder, RELATIVE_VELOCITY_T):
+    builder.PrependFloat64Slot(12, RELATIVE_VELOCITY_T, 0.0)
+
+def AddRELATIVE_VELOCITY_T(builder, RELATIVE_VELOCITY_T):
+    CDMAddRELATIVE_VELOCITY_T(builder, RELATIVE_VELOCITY_T)
+
+def CDMAddRELATIVE_VELOCITY_N(builder, RELATIVE_VELOCITY_N):
+    builder.PrependFloat64Slot(13, RELATIVE_VELOCITY_N, 0.0)
+
+def AddRELATIVE_VELOCITY_N(builder, RELATIVE_VELOCITY_N):
+    CDMAddRELATIVE_VELOCITY_N(builder, RELATIVE_VELOCITY_N)
+
+def CDMAddSTART_SCREEN_PERIOD(builder, START_SCREEN_PERIOD):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(START_SCREEN_PERIOD), 0)
+
+def AddSTART_SCREEN_PERIOD(builder, START_SCREEN_PERIOD):
+    CDMAddSTART_SCREEN_PERIOD(builder, START_SCREEN_PERIOD)
+
+def CDMAddSTOP_SCREEN_PERIOD(builder, STOP_SCREEN_PERIOD):
+    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(STOP_SCREEN_PERIOD), 0)
+
+def AddSTOP_SCREEN_PERIOD(builder, STOP_SCREEN_PERIOD):
+    CDMAddSTOP_SCREEN_PERIOD(builder, STOP_SCREEN_PERIOD)
+
+def CDMAddSCREEN_VOLUME_FRAME(builder, SCREEN_VOLUME_FRAME):
+    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(SCREEN_VOLUME_FRAME), 0)
+
+def AddSCREEN_VOLUME_FRAME(builder, SCREEN_VOLUME_FRAME):
+    CDMAddSCREEN_VOLUME_FRAME(builder, SCREEN_VOLUME_FRAME)
+
+def CDMAddSCREEN_VOLUME_SHAPE(builder, SCREEN_VOLUME_SHAPE):
+    builder.PrependInt8Slot(17, SCREEN_VOLUME_SHAPE, 0)
+
+def AddSCREEN_VOLUME_SHAPE(builder, SCREEN_VOLUME_SHAPE):
+    CDMAddSCREEN_VOLUME_SHAPE(builder, SCREEN_VOLUME_SHAPE)
+
+def CDMAddSCREEN_VOLUME_X(builder, SCREEN_VOLUME_X):
+    builder.PrependFloat64Slot(18, SCREEN_VOLUME_X, 0.0)
+
+def AddSCREEN_VOLUME_X(builder, SCREEN_VOLUME_X):
+    CDMAddSCREEN_VOLUME_X(builder, SCREEN_VOLUME_X)
+
+def CDMAddSCREEN_VOLUME_Y(builder, SCREEN_VOLUME_Y):
+    builder.PrependFloat64Slot(19, SCREEN_VOLUME_Y, 0.0)
+
+def AddSCREEN_VOLUME_Y(builder, SCREEN_VOLUME_Y):
+    CDMAddSCREEN_VOLUME_Y(builder, SCREEN_VOLUME_Y)
+
+def CDMAddSCREEN_VOLUME_Z(builder, SCREEN_VOLUME_Z):
+    builder.PrependFloat64Slot(20, SCREEN_VOLUME_Z, 0.0)
+
+def AddSCREEN_VOLUME_Z(builder, SCREEN_VOLUME_Z):
+    CDMAddSCREEN_VOLUME_Z(builder, SCREEN_VOLUME_Z)
+
+def CDMAddSCREEN_ENTRY_TIME(builder, SCREEN_ENTRY_TIME):
+    builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(SCREEN_ENTRY_TIME), 0)
+
+def AddSCREEN_ENTRY_TIME(builder, SCREEN_ENTRY_TIME):
+    CDMAddSCREEN_ENTRY_TIME(builder, SCREEN_ENTRY_TIME)
+
+def CDMAddSCREEN_EXIT_TIME(builder, SCREEN_EXIT_TIME):
+    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(SCREEN_EXIT_TIME), 0)
+
+def AddSCREEN_EXIT_TIME(builder, SCREEN_EXIT_TIME):
+    CDMAddSCREEN_EXIT_TIME(builder, SCREEN_EXIT_TIME)
+
+def CDMAddCOLLISION_PROBABILITY(builder, COLLISION_PROBABILITY):
+    builder.PrependFloat64Slot(23, COLLISION_PROBABILITY, 0.0)
+
+def AddCOLLISION_PROBABILITY(builder, COLLISION_PROBABILITY):
+    CDMAddCOLLISION_PROBABILITY(builder, COLLISION_PROBABILITY)
+
+def CDMAddCOLLISION_PROBABILITY_METHOD(builder, COLLISION_PROBABILITY_METHOD):
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(COLLISION_PROBABILITY_METHOD), 0)
+
+def AddCOLLISION_PROBABILITY_METHOD(builder, COLLISION_PROBABILITY_METHOD):
+    CDMAddCOLLISION_PROBABILITY_METHOD(builder, COLLISION_PROBABILITY_METHOD)
+
+def CDMAddOBJECT1(builder, OBJECT1):
+    builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT1), 0)
+
+def AddOBJECT1(builder, OBJECT1):
+    CDMAddOBJECT1(builder, OBJECT1)
+
+def CDMAddOBJECT2(builder, OBJECT2):
+    builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT2), 0)
+
+def AddOBJECT2(builder, OBJECT2):
+    CDMAddOBJECT2(builder, OBJECT2)
+
+def CDMAddOBJECT1_DATASOURCE(builder, OBJECT1_DATASOURCE):
+    builder.PrependUOffsetTRelativeSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT1_DATASOURCE), 0)
+
+def AddOBJECT1_DATASOURCE(builder, OBJECT1_DATASOURCE):
+    CDMAddOBJECT1_DATASOURCE(builder, OBJECT1_DATASOURCE)
+
+def CDMAddOBJECT2_DATASOURCE(builder, OBJECT2_DATASOURCE):
+    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT2_DATASOURCE), 0)
+
+def AddOBJECT2_DATASOURCE(builder, OBJECT2_DATASOURCE):
+    CDMAddOBJECT2_DATASOURCE(builder, OBJECT2_DATASOURCE)
+
+def CDMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CDMEnd(builder)
+
+import CDMObject
+import PNM
+import RFM
+try:
+    from typing import Optional
+except:
+    pass
+
+class CDMT(object):
+
+    # CDMT
+    def __init__(self):
+        self.CCSDS_CDM_VERS = 0.0  # type: float
+        self.CREATION_DATE = None  # type: str
+        self.ORIGINATOR = None  # type: str
+        self.MESSAGE_FOR = None  # type: str
+        self.MESSAGE_ID = None  # type: str
+        self.TCA = None  # type: str
+        self.MISS_DISTANCE = 0.0  # type: float
+        self.RELATIVE_SPEED = 0.0  # type: float
+        self.RELATIVE_POSITION_R = 0.0  # type: float
+        self.RELATIVE_POSITION_T = 0.0  # type: float
+        self.RELATIVE_POSITION_N = 0.0  # type: float
+        self.RELATIVE_VELOCITY_R = 0.0  # type: float
+        self.RELATIVE_VELOCITY_T = 0.0  # type: float
+        self.RELATIVE_VELOCITY_N = 0.0  # type: float
+        self.START_SCREEN_PERIOD = None  # type: str
+        self.STOP_SCREEN_PERIOD = None  # type: str
+        self.SCREEN_VOLUME_FRAME = None  # type: Optional[RFM.RFMT]
+        self.SCREEN_VOLUME_SHAPE = 0  # type: int
+        self.SCREEN_VOLUME_X = 0.0  # type: float
+        self.SCREEN_VOLUME_Y = 0.0  # type: float
+        self.SCREEN_VOLUME_Z = 0.0  # type: float
+        self.SCREEN_ENTRY_TIME = None  # type: str
+        self.SCREEN_EXIT_TIME = None  # type: str
+        self.COLLISION_PROBABILITY = 0.0  # type: float
+        self.COLLISION_PROBABILITY_METHOD = None  # type: str
+        self.OBJECT1 = None  # type: Optional[CDMObject.CDMObjectT]
+        self.OBJECT2 = None  # type: Optional[CDMObject.CDMObjectT]
+        self.OBJECT1_DATASOURCE = None  # type: Optional[PNM.PNMT]
+        self.OBJECT2_DATASOURCE = None  # type: Optional[PNM.PNMT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        CDM = CDM()
+        CDM.Init(buf, pos)
+        return cls.InitFromObj(CDM)
+
+    @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, CDM):
+        x = CDMT()
+        x._UnPack(CDM)
+        return x
+
+    # CDMT
+    def _UnPack(self, CDM):
+        if CDM is None:
+            return
+        self.CCSDS_CDM_VERS = CDM.CCSDS_CDM_VERS()
+        self.CREATION_DATE = CDM.CREATION_DATE()
+        self.ORIGINATOR = CDM.ORIGINATOR()
+        self.MESSAGE_FOR = CDM.MESSAGE_FOR()
+        self.MESSAGE_ID = CDM.MESSAGE_ID()
+        self.TCA = CDM.TCA()
+        self.MISS_DISTANCE = CDM.MISS_DISTANCE()
+        self.RELATIVE_SPEED = CDM.RELATIVE_SPEED()
+        self.RELATIVE_POSITION_R = CDM.RELATIVE_POSITION_R()
+        self.RELATIVE_POSITION_T = CDM.RELATIVE_POSITION_T()
+        self.RELATIVE_POSITION_N = CDM.RELATIVE_POSITION_N()
+        self.RELATIVE_VELOCITY_R = CDM.RELATIVE_VELOCITY_R()
+        self.RELATIVE_VELOCITY_T = CDM.RELATIVE_VELOCITY_T()
+        self.RELATIVE_VELOCITY_N = CDM.RELATIVE_VELOCITY_N()
+        self.START_SCREEN_PERIOD = CDM.START_SCREEN_PERIOD()
+        self.STOP_SCREEN_PERIOD = CDM.STOP_SCREEN_PERIOD()
+        if CDM.SCREEN_VOLUME_FRAME() is not None:
+            self.SCREEN_VOLUME_FRAME = RFM.RFMT.InitFromObj(CDM.SCREEN_VOLUME_FRAME())
+        self.SCREEN_VOLUME_SHAPE = CDM.SCREEN_VOLUME_SHAPE()
+        self.SCREEN_VOLUME_X = CDM.SCREEN_VOLUME_X()
+        self.SCREEN_VOLUME_Y = CDM.SCREEN_VOLUME_Y()
+        self.SCREEN_VOLUME_Z = CDM.SCREEN_VOLUME_Z()
+        self.SCREEN_ENTRY_TIME = CDM.SCREEN_ENTRY_TIME()
+        self.SCREEN_EXIT_TIME = CDM.SCREEN_EXIT_TIME()
+        self.COLLISION_PROBABILITY = CDM.COLLISION_PROBABILITY()
+        self.COLLISION_PROBABILITY_METHOD = CDM.COLLISION_PROBABILITY_METHOD()
+        if CDM.OBJECT1() is not None:
+            self.OBJECT1 = CDMObject.CDMObjectT.InitFromObj(CDM.OBJECT1())
+        if CDM.OBJECT2() is not None:
+            self.OBJECT2 = CDMObject.CDMObjectT.InitFromObj(CDM.OBJECT2())
+        if CDM.OBJECT1_DATASOURCE() is not None:
+            self.OBJECT1_DATASOURCE = PNM.PNMT.InitFromObj(CDM.OBJECT1_DATASOURCE())
+        if CDM.OBJECT2_DATASOURCE() is not None:
+            self.OBJECT2_DATASOURCE = PNM.PNMT.InitFromObj(CDM.OBJECT2_DATASOURCE())
+
+    # CDMT
+    def Pack(self, builder):
+        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.MESSAGE_FOR is not None:
+            MESSAGE_FOR = builder.CreateString(self.MESSAGE_FOR)
+        if self.MESSAGE_ID is not None:
+            MESSAGE_ID = builder.CreateString(self.MESSAGE_ID)
+        if self.TCA is not None:
+            TCA = builder.CreateString(self.TCA)
+        if self.START_SCREEN_PERIOD is not None:
+            START_SCREEN_PERIOD = builder.CreateString(self.START_SCREEN_PERIOD)
+        if self.STOP_SCREEN_PERIOD is not None:
+            STOP_SCREEN_PERIOD = builder.CreateString(self.STOP_SCREEN_PERIOD)
+        if self.SCREEN_VOLUME_FRAME is not None:
+            SCREEN_VOLUME_FRAME = self.SCREEN_VOLUME_FRAME.Pack(builder)
+        if self.SCREEN_ENTRY_TIME is not None:
+            SCREEN_ENTRY_TIME = builder.CreateString(self.SCREEN_ENTRY_TIME)
+        if self.SCREEN_EXIT_TIME is not None:
+            SCREEN_EXIT_TIME = builder.CreateString(self.SCREEN_EXIT_TIME)
+        if self.COLLISION_PROBABILITY_METHOD is not None:
+            COLLISION_PROBABILITY_METHOD = builder.CreateString(self.COLLISION_PROBABILITY_METHOD)
+        if self.OBJECT1 is not None:
+            OBJECT1 = self.OBJECT1.Pack(builder)
+        if self.OBJECT2 is not None:
+            OBJECT2 = self.OBJECT2.Pack(builder)
+        if self.OBJECT1_DATASOURCE is not None:
+            OBJECT1_DATASOURCE = self.OBJECT1_DATASOURCE.Pack(builder)
+        if self.OBJECT2_DATASOURCE is not None:
+            OBJECT2_DATASOURCE = self.OBJECT2_DATASOURCE.Pack(builder)
+        CDMStart(builder)
+        CDMAddCCSDS_CDM_VERS(builder, self.CCSDS_CDM_VERS)
+        if self.CREATION_DATE is not None:
+            CDMAddCREATION_DATE(builder, CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            CDMAddORIGINATOR(builder, ORIGINATOR)
+        if self.MESSAGE_FOR is not None:
+            CDMAddMESSAGE_FOR(builder, MESSAGE_FOR)
+        if self.MESSAGE_ID is not None:
+            CDMAddMESSAGE_ID(builder, MESSAGE_ID)
+        if self.TCA is not None:
+            CDMAddTCA(builder, TCA)
+        CDMAddMISS_DISTANCE(builder, self.MISS_DISTANCE)
+        CDMAddRELATIVE_SPEED(builder, self.RELATIVE_SPEED)
+        CDMAddRELATIVE_POSITION_R(builder, self.RELATIVE_POSITION_R)
+        CDMAddRELATIVE_POSITION_T(builder, self.RELATIVE_POSITION_T)
+        CDMAddRELATIVE_POSITION_N(builder, self.RELATIVE_POSITION_N)
+        CDMAddRELATIVE_VELOCITY_R(builder, self.RELATIVE_VELOCITY_R)
+        CDMAddRELATIVE_VELOCITY_T(builder, self.RELATIVE_VELOCITY_T)
+        CDMAddRELATIVE_VELOCITY_N(builder, self.RELATIVE_VELOCITY_N)
+        if self.START_SCREEN_PERIOD is not None:
+            CDMAddSTART_SCREEN_PERIOD(builder, START_SCREEN_PERIOD)
+        if self.STOP_SCREEN_PERIOD is not None:
+            CDMAddSTOP_SCREEN_PERIOD(builder, STOP_SCREEN_PERIOD)
+        if self.SCREEN_VOLUME_FRAME is not None:
+            CDMAddSCREEN_VOLUME_FRAME(builder, SCREEN_VOLUME_FRAME)
+        CDMAddSCREEN_VOLUME_SHAPE(builder, self.SCREEN_VOLUME_SHAPE)
+        CDMAddSCREEN_VOLUME_X(builder, self.SCREEN_VOLUME_X)
+        CDMAddSCREEN_VOLUME_Y(builder, self.SCREEN_VOLUME_Y)
+        CDMAddSCREEN_VOLUME_Z(builder, self.SCREEN_VOLUME_Z)
+        if self.SCREEN_ENTRY_TIME is not None:
+            CDMAddSCREEN_ENTRY_TIME(builder, SCREEN_ENTRY_TIME)
+        if self.SCREEN_EXIT_TIME is not None:
+            CDMAddSCREEN_EXIT_TIME(builder, SCREEN_EXIT_TIME)
+        CDMAddCOLLISION_PROBABILITY(builder, self.COLLISION_PROBABILITY)
+        if self.COLLISION_PROBABILITY_METHOD is not None:
+            CDMAddCOLLISION_PROBABILITY_METHOD(builder, COLLISION_PROBABILITY_METHOD)
+        if self.OBJECT1 is not None:
+            CDMAddOBJECT1(builder, OBJECT1)
+        if self.OBJECT2 is not None:
+            CDMAddOBJECT2(builder, OBJECT2)
+        if self.OBJECT1_DATASOURCE is not None:
+            CDMAddOBJECT1_DATASOURCE(builder, OBJECT1_DATASOURCE)
+        if self.OBJECT2_DATASOURCE is not None:
+            CDMAddOBJECT2_DATASOURCE(builder, OBJECT2_DATASOURCE)
+        CDM = CDMEnd(builder)
+        return CDM