spacedatastandards.org 1.73.0__py3-none-any.whl

VCM/keplerianElements.py

@@ -0,0 +1,184 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Keplerian Elements
+class keplerianElements(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = keplerianElements()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAskeplerianElements(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # keplerianElements
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # keplerianElements
+    def SEMI_MAJOR_AXIS(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
+
+    # keplerianElements
+    def ECCENTRICITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # keplerianElements
+    def INCLINATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # keplerianElements
+    def RA_OF_ASC_NODE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # keplerianElements
+    def ARG_OF_PERICENTER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # keplerianElements
+    def ANOMALY_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # keplerianElements
+    def ANOMALY(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
+
+def keplerianElementsStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    keplerianElementsStart(builder)
+
+def keplerianElementsAddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS):
+    builder.PrependFloat64Slot(0, SEMI_MAJOR_AXIS, 0.0)
+
+def AddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS):
+    keplerianElementsAddSEMI_MAJOR_AXIS(builder, SEMI_MAJOR_AXIS)
+
+def keplerianElementsAddECCENTRICITY(builder, ECCENTRICITY):
+    builder.PrependFloat64Slot(1, ECCENTRICITY, 0.0)
+
+def AddECCENTRICITY(builder, ECCENTRICITY):
+    keplerianElementsAddECCENTRICITY(builder, ECCENTRICITY)
+
+def keplerianElementsAddINCLINATION(builder, INCLINATION):
+    builder.PrependFloat64Slot(2, INCLINATION, 0.0)
+
+def AddINCLINATION(builder, INCLINATION):
+    keplerianElementsAddINCLINATION(builder, INCLINATION)
+
+def keplerianElementsAddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE):
+    builder.PrependFloat64Slot(3, RA_OF_ASC_NODE, 0.0)
+
+def AddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE):
+    keplerianElementsAddRA_OF_ASC_NODE(builder, RA_OF_ASC_NODE)
+
+def keplerianElementsAddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER):
+    builder.PrependFloat64Slot(4, ARG_OF_PERICENTER, 0.0)
+
+def AddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER):
+    keplerianElementsAddARG_OF_PERICENTER(builder, ARG_OF_PERICENTER)
+
+def keplerianElementsAddANOMALY_TYPE(builder, ANOMALY_TYPE):
+    builder.PrependInt8Slot(5, ANOMALY_TYPE, 0)
+
+def AddANOMALY_TYPE(builder, ANOMALY_TYPE):
+    keplerianElementsAddANOMALY_TYPE(builder, ANOMALY_TYPE)
+
+def keplerianElementsAddANOMALY(builder, ANOMALY):
+    builder.PrependFloat64Slot(6, ANOMALY, 0.0)
+
+def AddANOMALY(builder, ANOMALY):
+    keplerianElementsAddANOMALY(builder, ANOMALY)
+
+def keplerianElementsEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return keplerianElementsEnd(builder)
+
+
+class keplerianElementsT(object):
+
+    # keplerianElementsT
+    def __init__(self):
+        self.SEMI_MAJOR_AXIS = 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.ANOMALY_TYPE = 0  # type: int
+        self.ANOMALY = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        keplerianElements = keplerianElements()
+        keplerianElements.Init(buf, pos)
+        return cls.InitFromObj(keplerianElements)
+
+    @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, keplerianElements):
+        x = keplerianElementsT()
+        x._UnPack(keplerianElements)
+        return x
+
+    # keplerianElementsT
+    def _UnPack(self, keplerianElements):
+        if keplerianElements is None:
+            return
+        self.SEMI_MAJOR_AXIS = keplerianElements.SEMI_MAJOR_AXIS()
+        self.ECCENTRICITY = keplerianElements.ECCENTRICITY()
+        self.INCLINATION = keplerianElements.INCLINATION()
+        self.RA_OF_ASC_NODE = keplerianElements.RA_OF_ASC_NODE()
+        self.ARG_OF_PERICENTER = keplerianElements.ARG_OF_PERICENTER()
+        self.ANOMALY_TYPE = keplerianElements.ANOMALY_TYPE()
+        self.ANOMALY = keplerianElements.ANOMALY()
+
+    # keplerianElementsT
+    def Pack(self, builder):
+        keplerianElementsStart(builder)
+        keplerianElementsAddSEMI_MAJOR_AXIS(builder, self.SEMI_MAJOR_AXIS)
+        keplerianElementsAddECCENTRICITY(builder, self.ECCENTRICITY)
+        keplerianElementsAddINCLINATION(builder, self.INCLINATION)
+        keplerianElementsAddRA_OF_ASC_NODE(builder, self.RA_OF_ASC_NODE)
+        keplerianElementsAddARG_OF_PERICENTER(builder, self.ARG_OF_PERICENTER)
+        keplerianElementsAddANOMALY_TYPE(builder, self.ANOMALY_TYPE)
+        keplerianElementsAddANOMALY(builder, self.ANOMALY)
+        keplerianElements = keplerianElementsEnd(builder)
+        return keplerianElements

VCM/lunarPerturbationModel.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent common lunar perturbation models
+class lunarPerturbationModel(object):
+    NONE = 0
+    DE430 = 1
+    DE431 = 2
+    LP150Q = 3

VCM/meanElementTheory.py

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

VCM/perturbationStatus.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent the status of various perturbations (ON/OFF)
+class perturbationStatus(object):
+    OFF = 0
+    ON = 1

VCM/propagatorConfig.py

@@ -0,0 +1,250 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Propagator configuration structure to describe propagation settings
+class propagatorConfig(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = propagatorConfig()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAspropagatorConfig(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # propagatorConfig
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # propagatorConfig
+    def PROPAGATOR_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # propagatorConfig
+    def PROPAGATOR_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # propagatorConfig
+    def FORCE_MODELS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # propagatorConfig
+    def FORCE_MODELSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # propagatorConfig
+    def FORCE_MODELSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # propagatorConfig
+    def EPOCH(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
+
+    # propagatorConfig
+    def TIME_STEP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # propagatorConfig
+    def ZONAL_HARMONIC_TERMS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # propagatorConfig
+    def ZONAL_HARMONIC_TERMSAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # propagatorConfig
+    def ZONAL_HARMONIC_TERMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # propagatorConfig
+    def ZONAL_HARMONIC_TERMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+def propagatorConfigStart(builder):
+    builder.StartObject(6)
+
+def Start(builder):
+    propagatorConfigStart(builder)
+
+def propagatorConfigAddPROPAGATOR_NAME(builder, PROPAGATOR_NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PROPAGATOR_NAME), 0)
+
+def AddPROPAGATOR_NAME(builder, PROPAGATOR_NAME):
+    propagatorConfigAddPROPAGATOR_NAME(builder, PROPAGATOR_NAME)
+
+def propagatorConfigAddPROPAGATOR_TYPE(builder, PROPAGATOR_TYPE):
+    builder.PrependInt8Slot(1, PROPAGATOR_TYPE, 0)
+
+def AddPROPAGATOR_TYPE(builder, PROPAGATOR_TYPE):
+    propagatorConfigAddPROPAGATOR_TYPE(builder, PROPAGATOR_TYPE)
+
+def propagatorConfigAddFORCE_MODELS(builder, FORCE_MODELS):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(FORCE_MODELS), 0)
+
+def AddFORCE_MODELS(builder, FORCE_MODELS):
+    propagatorConfigAddFORCE_MODELS(builder, FORCE_MODELS)
+
+def propagatorConfigStartFORCE_MODELSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartFORCE_MODELSVector(builder, numElems):
+    return propagatorConfigStartFORCE_MODELSVector(builder, numElems)
+
+def propagatorConfigAddEPOCH(builder, EPOCH):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(EPOCH), 0)
+
+def AddEPOCH(builder, EPOCH):
+    propagatorConfigAddEPOCH(builder, EPOCH)
+
+def propagatorConfigAddTIME_STEP(builder, TIME_STEP):
+    builder.PrependFloat64Slot(4, TIME_STEP, 0.0)
+
+def AddTIME_STEP(builder, TIME_STEP):
+    propagatorConfigAddTIME_STEP(builder, TIME_STEP)
+
+def propagatorConfigAddZONAL_HARMONIC_TERMS(builder, ZONAL_HARMONIC_TERMS):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(ZONAL_HARMONIC_TERMS), 0)
+
+def AddZONAL_HARMONIC_TERMS(builder, ZONAL_HARMONIC_TERMS):
+    propagatorConfigAddZONAL_HARMONIC_TERMS(builder, ZONAL_HARMONIC_TERMS)
+
+def propagatorConfigStartZONAL_HARMONIC_TERMSVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartZONAL_HARMONIC_TERMSVector(builder, numElems):
+    return propagatorConfigStartZONAL_HARMONIC_TERMSVector(builder, numElems)
+
+def propagatorConfigEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return propagatorConfigEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class propagatorConfigT(object):
+
+    # propagatorConfigT
+    def __init__(self):
+        self.PROPAGATOR_NAME = None  # type: str
+        self.PROPAGATOR_TYPE = 0  # type: int
+        self.FORCE_MODELS = None  # type: List[str]
+        self.EPOCH = None  # type: str
+        self.TIME_STEP = 0.0  # type: float
+        self.ZONAL_HARMONIC_TERMS = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        propagatorConfig = propagatorConfig()
+        propagatorConfig.Init(buf, pos)
+        return cls.InitFromObj(propagatorConfig)
+
+    @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, propagatorConfig):
+        x = propagatorConfigT()
+        x._UnPack(propagatorConfig)
+        return x
+
+    # propagatorConfigT
+    def _UnPack(self, propagatorConfig):
+        if propagatorConfig is None:
+            return
+        self.PROPAGATOR_NAME = propagatorConfig.PROPAGATOR_NAME()
+        self.PROPAGATOR_TYPE = propagatorConfig.PROPAGATOR_TYPE()
+        if not propagatorConfig.FORCE_MODELSIsNone():
+            self.FORCE_MODELS = []
+            for i in range(propagatorConfig.FORCE_MODELSLength()):
+                self.FORCE_MODELS.append(propagatorConfig.FORCE_MODELS(i))
+        self.EPOCH = propagatorConfig.EPOCH()
+        self.TIME_STEP = propagatorConfig.TIME_STEP()
+        if not propagatorConfig.ZONAL_HARMONIC_TERMSIsNone():
+            if np is None:
+                self.ZONAL_HARMONIC_TERMS = []
+                for i in range(propagatorConfig.ZONAL_HARMONIC_TERMSLength()):
+                    self.ZONAL_HARMONIC_TERMS.append(propagatorConfig.ZONAL_HARMONIC_TERMS(i))
+            else:
+                self.ZONAL_HARMONIC_TERMS = propagatorConfig.ZONAL_HARMONIC_TERMSAsNumpy()
+
+    # propagatorConfigT
+    def Pack(self, builder):
+        if self.PROPAGATOR_NAME is not None:
+            PROPAGATOR_NAME = builder.CreateString(self.PROPAGATOR_NAME)
+        if self.FORCE_MODELS is not None:
+            FORCE_MODELSlist = []
+            for i in range(len(self.FORCE_MODELS)):
+                FORCE_MODELSlist.append(builder.CreateString(self.FORCE_MODELS[i]))
+            propagatorConfigStartFORCE_MODELSVector(builder, len(self.FORCE_MODELS))
+            for i in reversed(range(len(self.FORCE_MODELS))):
+                builder.PrependUOffsetTRelative(FORCE_MODELSlist[i])
+            FORCE_MODELS = builder.EndVector()
+        if self.EPOCH is not None:
+            EPOCH = builder.CreateString(self.EPOCH)
+        if self.ZONAL_HARMONIC_TERMS is not None:
+            if np is not None and type(self.ZONAL_HARMONIC_TERMS) is np.ndarray:
+                ZONAL_HARMONIC_TERMS = builder.CreateNumpyVector(self.ZONAL_HARMONIC_TERMS)
+            else:
+                propagatorConfigStartZONAL_HARMONIC_TERMSVector(builder, len(self.ZONAL_HARMONIC_TERMS))
+                for i in reversed(range(len(self.ZONAL_HARMONIC_TERMS))):
+                    builder.PrependByte(self.ZONAL_HARMONIC_TERMS[i])
+                ZONAL_HARMONIC_TERMS = builder.EndVector()
+        propagatorConfigStart(builder)
+        if self.PROPAGATOR_NAME is not None:
+            propagatorConfigAddPROPAGATOR_NAME(builder, PROPAGATOR_NAME)
+        propagatorConfigAddPROPAGATOR_TYPE(builder, self.PROPAGATOR_TYPE)
+        if self.FORCE_MODELS is not None:
+            propagatorConfigAddFORCE_MODELS(builder, FORCE_MODELS)
+        if self.EPOCH is not None:
+            propagatorConfigAddEPOCH(builder, EPOCH)
+        propagatorConfigAddTIME_STEP(builder, self.TIME_STEP)
+        if self.ZONAL_HARMONIC_TERMS is not None:
+            propagatorConfigAddZONAL_HARMONIC_TERMS(builder, ZONAL_HARMONIC_TERMS)
+        propagatorConfig = propagatorConfigEnd(builder)
+        return propagatorConfig

VCM/propagatorType.py

@@ -0,0 +1,19 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent propagator types
+class propagatorType(object):
+    NONE = 0
+    SEMI_ANALYTICAL = 1
+    VINTI = 2
+    SGP4 = 3
+    COWELL = 4
+    RK4 = 5
+    NYX = 6
+    GMAT = 7
+    SPICE = 8
+    SGP = 9
+    SDP4 = 10
+    SGP8 = 11
+    SDP8 = 12

VCM/resonanceModel.py

@@ -0,0 +1,11 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent resonance models
+class resonanceModel(object):
+    NONE = 0
+    HIGH_ALTITUDE_RESONANCE = 1
+    LOW_ALTITUDE_RESONANCE = 2
+    LUNAR_RESONANCE = 3
+    SOLAR_RESONANCE = 4

VCM/solarPerturbationModel.py

@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent various solar perturbation models
+class solarPerturbationModel(object):
+    NONE = 0
+    DE430 = 1
+    DE431 = 2

VCM/solarRadiationPressureModel.py

@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Enum to represent solar radiation pressure models
+class solarRadiationPressureModel(object):
+    NONE = 0
+    SPHERICAL_MODEL = 1
+    FLAT_PLATE_MODEL = 2

VCM/timeSystem.py

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

VCM/uvwSigmas.py

@@ -0,0 +1,168 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# UVW Sigmas (Covariance matrix in UVW frame)
+class uvwSigmas(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = uvwSigmas()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsuvwSigmas(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # uvwSigmas
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # uvwSigmas
+    def U_SIGMA(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
+
+    # uvwSigmas
+    def V_SIGMA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # uvwSigmas
+    def W_SIGMA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # uvwSigmas
+    def UD_SIGMA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # uvwSigmas
+    def VD_SIGMA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # uvwSigmas
+    def WD_SIGMA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def uvwSigmasStart(builder):
+    builder.StartObject(6)
+
+def Start(builder):
+    uvwSigmasStart(builder)
+
+def uvwSigmasAddU_SIGMA(builder, U_SIGMA):
+    builder.PrependFloat64Slot(0, U_SIGMA, 0.0)
+
+def AddU_SIGMA(builder, U_SIGMA):
+    uvwSigmasAddU_SIGMA(builder, U_SIGMA)
+
+def uvwSigmasAddV_SIGMA(builder, V_SIGMA):
+    builder.PrependFloat64Slot(1, V_SIGMA, 0.0)
+
+def AddV_SIGMA(builder, V_SIGMA):
+    uvwSigmasAddV_SIGMA(builder, V_SIGMA)
+
+def uvwSigmasAddW_SIGMA(builder, W_SIGMA):
+    builder.PrependFloat64Slot(2, W_SIGMA, 0.0)
+
+def AddW_SIGMA(builder, W_SIGMA):
+    uvwSigmasAddW_SIGMA(builder, W_SIGMA)
+
+def uvwSigmasAddUD_SIGMA(builder, UD_SIGMA):
+    builder.PrependFloat64Slot(3, UD_SIGMA, 0.0)
+
+def AddUD_SIGMA(builder, UD_SIGMA):
+    uvwSigmasAddUD_SIGMA(builder, UD_SIGMA)
+
+def uvwSigmasAddVD_SIGMA(builder, VD_SIGMA):
+    builder.PrependFloat64Slot(4, VD_SIGMA, 0.0)
+
+def AddVD_SIGMA(builder, VD_SIGMA):
+    uvwSigmasAddVD_SIGMA(builder, VD_SIGMA)
+
+def uvwSigmasAddWD_SIGMA(builder, WD_SIGMA):
+    builder.PrependFloat64Slot(5, WD_SIGMA, 0.0)
+
+def AddWD_SIGMA(builder, WD_SIGMA):
+    uvwSigmasAddWD_SIGMA(builder, WD_SIGMA)
+
+def uvwSigmasEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return uvwSigmasEnd(builder)
+
+
+class uvwSigmasT(object):
+
+    # uvwSigmasT
+    def __init__(self):
+        self.U_SIGMA = 0.0  # type: float
+        self.V_SIGMA = 0.0  # type: float
+        self.W_SIGMA = 0.0  # type: float
+        self.UD_SIGMA = 0.0  # type: float
+        self.VD_SIGMA = 0.0  # type: float
+        self.WD_SIGMA = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        uvwSigmas = uvwSigmas()
+        uvwSigmas.Init(buf, pos)
+        return cls.InitFromObj(uvwSigmas)
+
+    @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, uvwSigmas):
+        x = uvwSigmasT()
+        x._UnPack(uvwSigmas)
+        return x
+
+    # uvwSigmasT
+    def _UnPack(self, uvwSigmas):
+        if uvwSigmas is None:
+            return
+        self.U_SIGMA = uvwSigmas.U_SIGMA()
+        self.V_SIGMA = uvwSigmas.V_SIGMA()
+        self.W_SIGMA = uvwSigmas.W_SIGMA()
+        self.UD_SIGMA = uvwSigmas.UD_SIGMA()
+        self.VD_SIGMA = uvwSigmas.VD_SIGMA()
+        self.WD_SIGMA = uvwSigmas.WD_SIGMA()
+
+    # uvwSigmasT
+    def Pack(self, builder):
+        uvwSigmasStart(builder)
+        uvwSigmasAddU_SIGMA(builder, self.U_SIGMA)
+        uvwSigmasAddV_SIGMA(builder, self.V_SIGMA)
+        uvwSigmasAddW_SIGMA(builder, self.W_SIGMA)
+        uvwSigmasAddUD_SIGMA(builder, self.UD_SIGMA)
+        uvwSigmasAddVD_SIGMA(builder, self.VD_SIGMA)
+        uvwSigmasAddWD_SIGMA(builder, self.WD_SIGMA)
+        uvwSigmas = uvwSigmasEnd(builder)
+        return uvwSigmas