spacedatastandards.org 1.73.0__py3-none-any.whl

OMM/OMM.py

@@ -0,0 +1,860 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Orbit Mean Elements Message
+class OMM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = OMM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsOMM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def OMMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4F\x4D\x4D", size_prefixed=size_prefixed)
+
+    # OMM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CCSDS OMM Version
+    # OMM
+    def CCSDS_OMM_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
+
+    # Creation Date (ISO 8601 UTC format)
+    # OMM
+    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
+
+    # Originator
+    # OMM
+    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
+
+    # Satellite Name(s)
+    # OMM
+    def OBJECT_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
+
+    # International Designator (YYYY-NNNAAA)
+    # OMM
+    def OBJECT_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
+
+    # Center Name (e.g. EARTH, MARS)
+    # OMM
+    def CENTER_NAME(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
+
+    # Reference Frame
+    # Typically TEMEOFDATE
+    # OMM
+    def REFERENCE_FRAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        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 Epoch (ISO 8601 UTC format)
+    # OMM
+    def REFERENCE_FRAME_EPOCH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Time System [M, UTC]
+    # OMM
+    def TIME_SYSTEM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 11
+
+    # Mean Element Theory
+    # OMM
+    def MEAN_ELEMENT_THEORY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # COMMENT (O)
+    # OMM
+    def COMMENT(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
+
+    # EPOCH of Mean Keplerian elements (ISO 8601 UTC format)
+    # OMM
+    def EPOCH(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
+
+    # Semi-major axis in km or Mean Motion in rev/day
+    # OMM
+    def SEMI_MAJOR_AXIS(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
+
+    # Mean motion in rev/day if MEAN_ELEMENT_THEORY=SGP/SGP4 else unused
+    # OMM
+    def MEAN_MOTION(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
+
+    # Eccentricity (unitless)
+    # OMM
+    def ECCENTRICITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Inclination in degrees
+    # OMM
+    def INCLINATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RA_OF_ASC_NODE in degrees
+    # OMM
+    def RA_OF_ASC_NODE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # ARG_OF_PERICENTER in degrees
+    # OMM
+    def ARG_OF_PERICENTER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MEAN_ANOMALY in degrees
+    # OMM
+    def MEAN_ANOMALY(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
+
+    # GM in km**3/s**2
+    # OMM
+    def GM(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
+
+    # MASS in kg
+    # OMM
+    def MASS(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
+
+    # SOLAR_RAD_AREA in m**2
+    # OMM
+    def SOLAR_RAD_AREA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # SOLAR_RAD_COEFF (unitless)
+    # OMM
+    def SOLAR_RAD_COEFF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # DRAG_AREA in m**2
+    # OMM
+    def DRAG_AREA(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
+
+    # DRAG_COEFF (unitless)
+    # OMM
+    def DRAG_COEFF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TLE Related Parameters (Only if MEAN_ELEMENT_THEORY=SGP/SGP4)
+    # EPHEMERIS_TYPE Default=0
+    # OMM
+    def EPHEMERIS_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 1
+
+    # CLASSIFICATION_TYPE Default=U
+    # OMM
+    def CLASSIFICATION_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # NORAD_CAT_ID (integer) [O if SGP/SGP4]
+    # OMM
+    def NORAD_CAT_ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # ELEMENT_SET_NO [O if SGP/SGP4]
+    # OMM
+    def ELEMENT_SET_NO(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # REV_AT_EPOCH [O if SGP/SGP4]
+    # OMM
+    def REV_AT_EPOCH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # BSTAR in 1/Earth radii or BTERM in m**2/kg depending on MEAN_ELEMENT_THEORY [C]
+    # OMM
+    def BSTAR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MEAN_MOTION_DOT in rev/day**2 [C if SGP or PPT3]
+    # OMM
+    def MEAN_MOTION_DOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MEAN_MOTION_DDOT in rev/day**3 if SGP/PPT3 or AGOM in m**2/kg if SGP4-XP [C]
+    # OMM
+    def MEAN_MOTION_DDOT(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
+
+    # Position/Velocity Covariance Matrix (6x6 Lower Triangular) [C if any covariance provided]
+    # COV_REF_FRAME reference frame for covariance [C if covariance given]
+    # Typically RSW
+    # OMM
+    def COV_REFERENCE_FRAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+        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
+
+    # Covariance matrix as flat array (6x6 lower triangular = 21 elements).
+    # Order: [CX_X, CY_X, CY_Y, CZ_X, CZ_Y, CZ_Z,
+    #         CX_DOT_X, CX_DOT_Y, CX_DOT_Z, CX_DOT_X_DOT,
+    #         CY_DOT_X, CY_DOT_Y, CY_DOT_Z, CY_DOT_X_DOT, CY_DOT_Y_DOT,
+    #         CZ_DOT_X, CZ_DOT_Y, CZ_DOT_Z, CZ_DOT_X_DOT, CZ_DOT_Y_DOT, CZ_DOT_Z_DOT]
+    # Units: position in km**2, velocity in km**2/s**2, cross in km**2/s
+    # OMM
+    def COVARIANCE(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        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
+
+    # OMM
+    def COVARIANCEAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
+
+    # OMM
+    def COVARIANCELength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # OMM
+    def COVARIANCEIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        return o == 0
+
+    # USER_DEFINED_BIP_0044_TYPE [O, units per ICD]
+    # OMM
+    def USER_DEFINED_BIP_0044_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # USER_DEFINED_OBJECT_DESIGNATOR [O, units per ICD]
+    # OMM
+    def USER_DEFINED_OBJECT_DESIGNATOR(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
+
+    # USER_DEFINED_EARTH_MODEL [O, units per ICD]
+    # OMM
+    def USER_DEFINED_EARTH_MODEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # USER_DEFINED_EPOCH_TIMESTAMP [O, units per ICD]
+    # OMM
+    def USER_DEFINED_EPOCH_TIMESTAMP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # USER_DEFINED_MICROSECONDS [O, units per ICD]
+    # OMM
+    def USER_DEFINED_MICROSECONDS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def OMMStart(builder):
+    builder.StartObject(40)
+
+def Start(builder):
+    OMMStart(builder)
+
+def OMMAddCCSDS_OMM_VERS(builder, CCSDS_OMM_VERS):
+    builder.PrependFloat64Slot(0, CCSDS_OMM_VERS, 0.0)
+
+def AddCCSDS_OMM_VERS(builder, CCSDS_OMM_VERS):
+    OMMAddCCSDS_OMM_VERS(builder, CCSDS_OMM_VERS)
+
+def OMMAddCREATION_DATE(builder, CREATION_DATE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CREATION_DATE), 0)
+
+def AddCREATION_DATE(builder, CREATION_DATE):
+    OMMAddCREATION_DATE(builder, CREATION_DATE)
+
+def OMMAddORIGINATOR(builder, ORIGINATOR):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(ORIGINATOR), 0)
+
+def AddORIGINATOR(builder, ORIGINATOR):
+    OMMAddORIGINATOR(builder, ORIGINATOR)
+
+def OMMAddOBJECT_NAME(builder, OBJECT_NAME):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT_NAME), 0)
+
+def AddOBJECT_NAME(builder, OBJECT_NAME):
+    OMMAddOBJECT_NAME(builder, OBJECT_NAME)
+
+def OMMAddOBJECT_ID(builder, OBJECT_ID):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(OBJECT_ID), 0)
+
+def AddOBJECT_ID(builder, OBJECT_ID):
+    OMMAddOBJECT_ID(builder, OBJECT_ID)
+
+def OMMAddCENTER_NAME(builder, CENTER_NAME):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(CENTER_NAME), 0)
+
+def AddCENTER_NAME(builder, CENTER_NAME):
+    OMMAddCENTER_NAME(builder, CENTER_NAME)
+
+def OMMAddREFERENCE_FRAME(builder, REFERENCE_FRAME):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(REFERENCE_FRAME), 0)
+
+def AddREFERENCE_FRAME(builder, REFERENCE_FRAME):
+    OMMAddREFERENCE_FRAME(builder, REFERENCE_FRAME)
+
+def OMMAddREFERENCE_FRAME_EPOCH(builder, REFERENCE_FRAME_EPOCH):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(REFERENCE_FRAME_EPOCH), 0)
+
+def AddREFERENCE_FRAME_EPOCH(builder, REFERENCE_FRAME_EPOCH):
+    OMMAddREFERENCE_FRAME_EPOCH(builder, REFERENCE_FRAME_EPOCH)
+
+def OMMAddTIME_SYSTEM(builder, TIME_SYSTEM):
+    builder.PrependInt8Slot(8, TIME_SYSTEM, 11)
+
+def AddTIME_SYSTEM(builder, TIME_SYSTEM):
+    OMMAddTIME_SYSTEM(builder, TIME_SYSTEM)
+
+def OMMAddMEAN_ELEMENT_THEORY(builder, MEAN_ELEMENT_THEORY):
+    builder.PrependInt8Slot(9, MEAN_ELEMENT_THEORY, 0)
+
+def AddMEAN_ELEMENT_THEORY(builder, MEAN_ELEMENT_THEORY):
+    OMMAddMEAN_ELEMENT_THEORY(builder, MEAN_ELEMENT_THEORY)
+
+def OMMAddCOMMENT(builder, COMMENT):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(COMMENT), 0)
+
+def AddCOMMENT(builder, COMMENT):
+    OMMAddCOMMENT(builder, COMMENT)
+
+def OMMAddEPOCH(builder, EPOCH):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(EPOCH), 0)
+
+def AddEPOCH(builder, EPOCH):
+    OMMAddEPOCH(builder, EPOCH)
+
+def OMMAddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS):
+    builder.PrependFloat64Slot(12, SEMI_MAJOR_AXIS, 0.0)
+
+def AddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS):
+    OMMAddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS)
+
+def OMMAddMEAN_MOTION(builder, MEAN_MOTION):
+    builder.PrependFloat64Slot(13, MEAN_MOTION, 0.0)
+
+def AddMEAN_MOTION(builder, MEAN_MOTION):
+    OMMAddMEAN_MOTION(builder, MEAN_MOTION)
+
+def OMMAddECCENTRICITY(builder, ECCENTRICITY):
+    builder.PrependFloat64Slot(14, ECCENTRICITY, 0.0)
+
+def AddECCENTRICITY(builder, ECCENTRICITY):
+    OMMAddECCENTRICITY(builder, ECCENTRICITY)
+
+def OMMAddINCLINATION(builder, INCLINATION):
+    builder.PrependFloat64Slot(15, INCLINATION, 0.0)
+
+def AddINCLINATION(builder, INCLINATION):
+    OMMAddINCLINATION(builder, INCLINATION)
+
+def OMMAddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE):
+    builder.PrependFloat64Slot(16, RA_OF_ASC_NODE, 0.0)
+
+def AddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE):
+    OMMAddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE)
+
+def OMMAddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER):
+    builder.PrependFloat64Slot(17, ARG_OF_PERICENTER, 0.0)
+
+def AddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER):
+    OMMAddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER)
+
+def OMMAddMEAN_ANOMALY(builder, MEAN_ANOMALY):
+    builder.PrependFloat64Slot(18, MEAN_ANOMALY, 0.0)
+
+def AddMEAN_ANOMALY(builder, MEAN_ANOMALY):
+    OMMAddMEAN_ANOMALY(builder, MEAN_ANOMALY)
+
+def OMMAddGM(builder, GM):
+    builder.PrependFloat64Slot(19, GM, 0.0)
+
+def AddGM(builder, GM):
+    OMMAddGM(builder, GM)
+
+def OMMAddMASS(builder, MASS):
+    builder.PrependFloat64Slot(20, MASS, 0.0)
+
+def AddMASS(builder, MASS):
+    OMMAddMASS(builder, MASS)
+
+def OMMAddSOLAR_RAD_AREA(builder, SOLAR_RAD_AREA):
+    builder.PrependFloat64Slot(21, SOLAR_RAD_AREA, 0.0)
+
+def AddSOLAR_RAD_AREA(builder, SOLAR_RAD_AREA):
+    OMMAddSOLAR_RAD_AREA(builder, SOLAR_RAD_AREA)
+
+def OMMAddSOLAR_RAD_COEFF(builder, SOLAR_RAD_COEFF):
+    builder.PrependFloat64Slot(22, SOLAR_RAD_COEFF, 0.0)
+
+def AddSOLAR_RAD_COEFF(builder, SOLAR_RAD_COEFF):
+    OMMAddSOLAR_RAD_COEFF(builder, SOLAR_RAD_COEFF)
+
+def OMMAddDRAG_AREA(builder, DRAG_AREA):
+    builder.PrependFloat64Slot(23, DRAG_AREA, 0.0)
+
+def AddDRAG_AREA(builder, DRAG_AREA):
+    OMMAddDRAG_AREA(builder, DRAG_AREA)
+
+def OMMAddDRAG_COEFF(builder, DRAG_COEFF):
+    builder.PrependFloat64Slot(24, DRAG_COEFF, 0.0)
+
+def AddDRAG_COEFF(builder, DRAG_COEFF):
+    OMMAddDRAG_COEFF(builder, DRAG_COEFF)
+
+def OMMAddEPHEMERIS_TYPE(builder, EPHEMERIS_TYPE):
+    builder.PrependInt8Slot(25, EPHEMERIS_TYPE, 1)
+
+def AddEPHEMERIS_TYPE(builder, EPHEMERIS_TYPE):
+    OMMAddEPHEMERIS_TYPE(builder, EPHEMERIS_TYPE)
+
+def OMMAddCLASSIFICATION_TYPE(builder, CLASSIFICATION_TYPE):
+    builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(CLASSIFICATION_TYPE), 0)
+
+def AddCLASSIFICATION_TYPE(builder, CLASSIFICATION_TYPE):
+    OMMAddCLASSIFICATION_TYPE(builder, CLASSIFICATION_TYPE)
+
+def OMMAddNORAD_CAT_ID(builder, NORAD_CAT_ID):
+    builder.PrependUint32Slot(27, NORAD_CAT_ID, 0)
+
+def AddNORAD_CAT_ID(builder, NORAD_CAT_ID):
+    OMMAddNORAD_CAT_ID(builder, NORAD_CAT_ID)
+
+def OMMAddELEMENT_SET_NO(builder, ELEMENT_SET_NO):
+    builder.PrependUint32Slot(28, ELEMENT_SET_NO, 0)
+
+def AddELEMENT_SET_NO(builder, ELEMENT_SET_NO):
+    OMMAddELEMENT_SET_NO(builder, ELEMENT_SET_NO)
+
+def OMMAddREV_AT_EPOCH(builder, REV_AT_EPOCH):
+    builder.PrependFloat64Slot(29, REV_AT_EPOCH, 0.0)
+
+def AddREV_AT_EPOCH(builder, REV_AT_EPOCH):
+    OMMAddREV_AT_EPOCH(builder, REV_AT_EPOCH)
+
+def OMMAddBSTAR(builder, BSTAR):
+    builder.PrependFloat64Slot(30, BSTAR, 0.0)
+
+def AddBSTAR(builder, BSTAR):
+    OMMAddBSTAR(builder, BSTAR)
+
+def OMMAddMEAN_MOTION_DOT(builder, MEAN_MOTION_DOT):
+    builder.PrependFloat64Slot(31, MEAN_MOTION_DOT, 0.0)
+
+def AddMEAN_MOTION_DOT(builder, MEAN_MOTION_DOT):
+    OMMAddMEAN_MOTION_DOT(builder, MEAN_MOTION_DOT)
+
+def OMMAddMEAN_MOTION_DDOT(builder, MEAN_MOTION_DDOT):
+    builder.PrependFloat64Slot(32, MEAN_MOTION_DDOT, 0.0)
+
+def AddMEAN_MOTION_DDOT(builder, MEAN_MOTION_DDOT):
+    OMMAddMEAN_MOTION_DDOT(builder, MEAN_MOTION_DDOT)
+
+def OMMAddCOV_REFERENCE_FRAME(builder, COV_REFERENCE_FRAME):
+    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(COV_REFERENCE_FRAME), 0)
+
+def AddCOV_REFERENCE_FRAME(builder, COV_REFERENCE_FRAME):
+    OMMAddCOV_REFERENCE_FRAME(builder, COV_REFERENCE_FRAME)
+
+def OMMAddCOVARIANCE(builder, COVARIANCE):
+    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(COVARIANCE), 0)
+
+def AddCOVARIANCE(builder, COVARIANCE):
+    OMMAddCOVARIANCE(builder, COVARIANCE)
+
+def OMMStartCOVARIANCEVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def StartCOVARIANCEVector(builder, numElems):
+    return OMMStartCOVARIANCEVector(builder, numElems)
+
+def OMMAddUSER_DEFINED_BIP_0044_TYPE(builder, USER_DEFINED_BIP_0044_TYPE):
+    builder.PrependUint32Slot(35, USER_DEFINED_BIP_0044_TYPE, 0)
+
+def AddUSER_DEFINED_BIP_0044_TYPE(builder, USER_DEFINED_BIP_0044_TYPE):
+    OMMAddUSER_DEFINED_BIP_0044_TYPE(builder, USER_DEFINED_BIP_0044_TYPE)
+
+def OMMAddUSER_DEFINED_OBJECT_DESIGNATOR(builder, USER_DEFINED_OBJECT_DESIGNATOR):
+    builder.PrependUOffsetTRelativeSlot(36, flatbuffers.number_types.UOffsetTFlags.py_type(USER_DEFINED_OBJECT_DESIGNATOR), 0)
+
+def AddUSER_DEFINED_OBJECT_DESIGNATOR(builder, USER_DEFINED_OBJECT_DESIGNATOR):
+    OMMAddUSER_DEFINED_OBJECT_DESIGNATOR(builder, USER_DEFINED_OBJECT_DESIGNATOR)
+
+def OMMAddUSER_DEFINED_EARTH_MODEL(builder, USER_DEFINED_EARTH_MODEL):
+    builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(USER_DEFINED_EARTH_MODEL), 0)
+
+def AddUSER_DEFINED_EARTH_MODEL(builder, USER_DEFINED_EARTH_MODEL):
+    OMMAddUSER_DEFINED_EARTH_MODEL(builder, USER_DEFINED_EARTH_MODEL)
+
+def OMMAddUSER_DEFINED_EPOCH_TIMESTAMP(builder, USER_DEFINED_EPOCH_TIMESTAMP):
+    builder.PrependFloat64Slot(38, USER_DEFINED_EPOCH_TIMESTAMP, 0.0)
+
+def AddUSER_DEFINED_EPOCH_TIMESTAMP(builder, USER_DEFINED_EPOCH_TIMESTAMP):
+    OMMAddUSER_DEFINED_EPOCH_TIMESTAMP(builder, USER_DEFINED_EPOCH_TIMESTAMP)
+
+def OMMAddUSER_DEFINED_MICROSECONDS(builder, USER_DEFINED_MICROSECONDS):
+    builder.PrependFloat64Slot(39, USER_DEFINED_MICROSECONDS, 0.0)
+
+def AddUSER_DEFINED_MICROSECONDS(builder, USER_DEFINED_MICROSECONDS):
+    OMMAddUSER_DEFINED_MICROSECONDS(builder, USER_DEFINED_MICROSECONDS)
+
+def OMMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return OMMEnd(builder)
+
+import RFM
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class OMMT(object):
+
+    # OMMT
+    def __init__(self):
+        self.CCSDS_OMM_VERS = 0.0  # type: float
+        self.CREATION_DATE = None  # type: str
+        self.ORIGINATOR = None  # type: str
+        self.OBJECT_NAME = None  # type: str
+        self.OBJECT_ID = None  # type: str
+        self.CENTER_NAME = None  # type: str
+        self.REFERENCE_FRAME = None  # type: Optional[RFM.RFMT]
+        self.REFERENCE_FRAME_EPOCH = None  # type: str
+        self.TIME_SYSTEM = 11  # type: int
+        self.MEAN_ELEMENT_THEORY = 0  # type: int
+        self.COMMENT = None  # type: str
+        self.EPOCH = None  # type: str
+        self.SEMI_MAJOR_AXIS = 0.0  # type: float
+        self.MEAN_MOTION = 0.0  # type: float
+        self.ECCENTRICITY = 0.0  # type: float
+        self.INCLINATION = 0.0  # type: float
+        self.RA_OF_ASC_NODE = 0.0  # type: float
+        self.ARG_OF_PERICENTER = 0.0  # type: float
+        self.MEAN_ANOMALY = 0.0  # type: float
+        self.GM = 0.0  # type: float
+        self.MASS = 0.0  # type: float
+        self.SOLAR_RAD_AREA = 0.0  # type: float
+        self.SOLAR_RAD_COEFF = 0.0  # type: float
+        self.DRAG_AREA = 0.0  # type: float
+        self.DRAG_COEFF = 0.0  # type: float
+        self.EPHEMERIS_TYPE = 1  # type: int
+        self.CLASSIFICATION_TYPE = None  # type: str
+        self.NORAD_CAT_ID = 0  # type: int
+        self.ELEMENT_SET_NO = 0  # type: int
+        self.REV_AT_EPOCH = 0.0  # type: float
+        self.BSTAR = 0.0  # type: float
+        self.MEAN_MOTION_DOT = 0.0  # type: float
+        self.MEAN_MOTION_DDOT = 0.0  # type: float
+        self.COV_REFERENCE_FRAME = None  # type: Optional[RFM.RFMT]
+        self.COVARIANCE = None  # type: List[float]
+        self.USER_DEFINED_BIP_0044_TYPE = 0  # type: int
+        self.USER_DEFINED_OBJECT_DESIGNATOR = None  # type: str
+        self.USER_DEFINED_EARTH_MODEL = None  # type: str
+        self.USER_DEFINED_EPOCH_TIMESTAMP = 0.0  # type: float
+        self.USER_DEFINED_MICROSECONDS = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        OMM = OMM()
+        OMM.Init(buf, pos)
+        return cls.InitFromObj(OMM)
+
+    @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, OMM):
+        x = OMMT()
+        x._UnPack(OMM)
+        return x
+
+    # OMMT
+    def _UnPack(self, OMM):
+        if OMM is None:
+            return
+        self.CCSDS_OMM_VERS = OMM.CCSDS_OMM_VERS()
+        self.CREATION_DATE = OMM.CREATION_DATE()
+        self.ORIGINATOR = OMM.ORIGINATOR()
+        self.OBJECT_NAME = OMM.OBJECT_NAME()
+        self.OBJECT_ID = OMM.OBJECT_ID()
+        self.CENTER_NAME = OMM.CENTER_NAME()
+        if OMM.REFERENCE_FRAME() is not None:
+            self.REFERENCE_FRAME = RFM.RFMT.InitFromObj(OMM.REFERENCE_FRAME())
+        self.REFERENCE_FRAME_EPOCH = OMM.REFERENCE_FRAME_EPOCH()
+        self.TIME_SYSTEM = OMM.TIME_SYSTEM()
+        self.MEAN_ELEMENT_THEORY = OMM.MEAN_ELEMENT_THEORY()
+        self.COMMENT = OMM.COMMENT()
+        self.EPOCH = OMM.EPOCH()
+        self.SEMI_MAJOR_AXIS = OMM.SEMI_MAJOR_AXIS()
+        self.MEAN_MOTION = OMM.MEAN_MOTION()
+        self.ECCENTRICITY = OMM.ECCENTRICITY()
+        self.INCLINATION = OMM.INCLINATION()
+        self.RA_OF_ASC_NODE = OMM.RA_OF_ASC_NODE()
+        self.ARG_OF_PERICENTER = OMM.ARG_OF_PERICENTER()
+        self.MEAN_ANOMALY = OMM.MEAN_ANOMALY()
+        self.GM = OMM.GM()
+        self.MASS = OMM.MASS()
+        self.SOLAR_RAD_AREA = OMM.SOLAR_RAD_AREA()
+        self.SOLAR_RAD_COEFF = OMM.SOLAR_RAD_COEFF()
+        self.DRAG_AREA = OMM.DRAG_AREA()
+        self.DRAG_COEFF = OMM.DRAG_COEFF()
+        self.EPHEMERIS_TYPE = OMM.EPHEMERIS_TYPE()
+        self.CLASSIFICATION_TYPE = OMM.CLASSIFICATION_TYPE()
+        self.NORAD_CAT_ID = OMM.NORAD_CAT_ID()
+        self.ELEMENT_SET_NO = OMM.ELEMENT_SET_NO()
+        self.REV_AT_EPOCH = OMM.REV_AT_EPOCH()
+        self.BSTAR = OMM.BSTAR()
+        self.MEAN_MOTION_DOT = OMM.MEAN_MOTION_DOT()
+        self.MEAN_MOTION_DDOT = OMM.MEAN_MOTION_DDOT()
+        if OMM.COV_REFERENCE_FRAME() is not None:
+            self.COV_REFERENCE_FRAME = RFM.RFMT.InitFromObj(OMM.COV_REFERENCE_FRAME())
+        if not OMM.COVARIANCEIsNone():
+            if np is None:
+                self.COVARIANCE = []
+                for i in range(OMM.COVARIANCELength()):
+                    self.COVARIANCE.append(OMM.COVARIANCE(i))
+            else:
+                self.COVARIANCE = OMM.COVARIANCEAsNumpy()
+        self.USER_DEFINED_BIP_0044_TYPE = OMM.USER_DEFINED_BIP_0044_TYPE()
+        self.USER_DEFINED_OBJECT_DESIGNATOR = OMM.USER_DEFINED_OBJECT_DESIGNATOR()
+        self.USER_DEFINED_EARTH_MODEL = OMM.USER_DEFINED_EARTH_MODEL()
+        self.USER_DEFINED_EPOCH_TIMESTAMP = OMM.USER_DEFINED_EPOCH_TIMESTAMP()
+        self.USER_DEFINED_MICROSECONDS = OMM.USER_DEFINED_MICROSECONDS()
+
+    # OMMT
+    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.OBJECT_NAME is not None:
+            OBJECT_NAME = builder.CreateString(self.OBJECT_NAME)
+        if self.OBJECT_ID is not None:
+            OBJECT_ID = builder.CreateString(self.OBJECT_ID)
+        if self.CENTER_NAME is not None:
+            CENTER_NAME = builder.CreateString(self.CENTER_NAME)
+        if self.REFERENCE_FRAME is not None:
+            REFERENCE_FRAME = self.REFERENCE_FRAME.Pack(builder)
+        if self.REFERENCE_FRAME_EPOCH is not None:
+            REFERENCE_FRAME_EPOCH = builder.CreateString(self.REFERENCE_FRAME_EPOCH)
+        if self.COMMENT is not None:
+            COMMENT = builder.CreateString(self.COMMENT)
+        if self.EPOCH is not None:
+            EPOCH = builder.CreateString(self.EPOCH)
+        if self.CLASSIFICATION_TYPE is not None:
+            CLASSIFICATION_TYPE = builder.CreateString(self.CLASSIFICATION_TYPE)
+        if self.COV_REFERENCE_FRAME is not None:
+            COV_REFERENCE_FRAME = self.COV_REFERENCE_FRAME.Pack(builder)
+        if self.COVARIANCE is not None:
+            if np is not None and type(self.COVARIANCE) is np.ndarray:
+                COVARIANCE = builder.CreateNumpyVector(self.COVARIANCE)
+            else:
+                OMMStartCOVARIANCEVector(builder, len(self.COVARIANCE))
+                for i in reversed(range(len(self.COVARIANCE))):
+                    builder.PrependFloat64(self.COVARIANCE[i])
+                COVARIANCE = builder.EndVector()
+        if self.USER_DEFINED_OBJECT_DESIGNATOR is not None:
+            USER_DEFINED_OBJECT_DESIGNATOR = builder.CreateString(self.USER_DEFINED_OBJECT_DESIGNATOR)
+        if self.USER_DEFINED_EARTH_MODEL is not None:
+            USER_DEFINED_EARTH_MODEL = builder.CreateString(self.USER_DEFINED_EARTH_MODEL)
+        OMMStart(builder)
+        OMMAddCCSDS_OMM_VERS(builder, self.CCSDS_OMM_VERS)
+        if self.CREATION_DATE is not None:
+            OMMAddCREATION_DATE(builder, CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            OMMAddORIGINATOR(builder, ORIGINATOR)
+        if self.OBJECT_NAME is not None:
+            OMMAddOBJECT_NAME(builder, OBJECT_NAME)
+        if self.OBJECT_ID is not None:
+            OMMAddOBJECT_ID(builder, OBJECT_ID)
+        if self.CENTER_NAME is not None:
+            OMMAddCENTER_NAME(builder, CENTER_NAME)
+        if self.REFERENCE_FRAME is not None:
+            OMMAddREFERENCE_FRAME(builder, REFERENCE_FRAME)
+        if self.REFERENCE_FRAME_EPOCH is not None:
+            OMMAddREFERENCE_FRAME_EPOCH(builder, REFERENCE_FRAME_EPOCH)
+        OMMAddTIME_SYSTEM(builder, self.TIME_SYSTEM)
+        OMMAddMEAN_ELEMENT_THEORY(builder, self.MEAN_ELEMENT_THEORY)
+        if self.COMMENT is not None:
+            OMMAddCOMMENT(builder, COMMENT)
+        if self.EPOCH is not None:
+            OMMAddEPOCH(builder, EPOCH)
+        OMMAddSEMI_MAJOR_AXIS(builder, self.SEMI_MAJOR_AXIS)
+        OMMAddMEAN_MOTION(builder, self.MEAN_MOTION)
+        OMMAddECCENTRICITY(builder, self.ECCENTRICITY)
+        OMMAddINCLINATION(builder, self.INCLINATION)
+        OMMAddRA_OF_ASC_NODE(builder, self.RA_OF_ASC_NODE)
+        OMMAddARG_OF_PERICENTER(builder, self.ARG_OF_PERICENTER)
+        OMMAddMEAN_ANOMALY(builder, self.MEAN_ANOMALY)
+        OMMAddGM(builder, self.GM)
+        OMMAddMASS(builder, self.MASS)
+        OMMAddSOLAR_RAD_AREA(builder, self.SOLAR_RAD_AREA)
+        OMMAddSOLAR_RAD_COEFF(builder, self.SOLAR_RAD_COEFF)
+        OMMAddDRAG_AREA(builder, self.DRAG_AREA)
+        OMMAddDRAG_COEFF(builder, self.DRAG_COEFF)
+        OMMAddEPHEMERIS_TYPE(builder, self.EPHEMERIS_TYPE)
+        if self.CLASSIFICATION_TYPE is not None:
+            OMMAddCLASSIFICATION_TYPE(builder, CLASSIFICATION_TYPE)
+        OMMAddNORAD_CAT_ID(builder, self.NORAD_CAT_ID)
+        OMMAddELEMENT_SET_NO(builder, self.ELEMENT_SET_NO)
+        OMMAddREV_AT_EPOCH(builder, self.REV_AT_EPOCH)
+        OMMAddBSTAR(builder, self.BSTAR)
+        OMMAddMEAN_MOTION_DOT(builder, self.MEAN_MOTION_DOT)
+        OMMAddMEAN_MOTION_DDOT(builder, self.MEAN_MOTION_DDOT)
+        if self.COV_REFERENCE_FRAME is not None:
+            OMMAddCOV_REFERENCE_FRAME(builder, COV_REFERENCE_FRAME)
+        if self.COVARIANCE is not None:
+            OMMAddCOVARIANCE(builder, COVARIANCE)
+        OMMAddUSER_DEFINED_BIP_0044_TYPE(builder, self.USER_DEFINED_BIP_0044_TYPE)
+        if self.USER_DEFINED_OBJECT_DESIGNATOR is not None:
+            OMMAddUSER_DEFINED_OBJECT_DESIGNATOR(builder, USER_DEFINED_OBJECT_DESIGNATOR)
+        if self.USER_DEFINED_EARTH_MODEL is not None:
+            OMMAddUSER_DEFINED_EARTH_MODEL(builder, USER_DEFINED_EARTH_MODEL)
+        OMMAddUSER_DEFINED_EPOCH_TIMESTAMP(builder, self.USER_DEFINED_EPOCH_TIMESTAMP)
+        OMMAddUSER_DEFINED_MICROSECONDS(builder, self.USER_DEFINED_MICROSECONDS)
+        OMM = OMMEnd(builder)
+        return OMM