spacedatastandards.org 1.73.0__py3-none-any.whl

ATM/ATM.py

@@ -0,0 +1,110 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Atmospheric Model Message
+class ATM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ATM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsATM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ATMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x41\x54\x4D", size_prefixed=size_prefixed)
+
+    # ATM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Canonical model family
+    # ATM
+    def MODEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Four-digit year identifying the model version (e.g., 1970, 2008, 2020)
+    # ATM
+    def YEAR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def ATMStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    ATMStart(builder)
+
+def ATMAddMODEL(builder, MODEL):
+    builder.PrependInt8Slot(0, MODEL, 0)
+
+def AddMODEL(builder, MODEL):
+    ATMAddMODEL(builder, MODEL)
+
+def ATMAddYEAR(builder, YEAR):
+    builder.PrependInt32Slot(1, YEAR, 0)
+
+def AddYEAR(builder, YEAR):
+    ATMAddYEAR(builder, YEAR)
+
+def ATMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ATMEnd(builder)
+
+
+class ATMT(object):
+
+    # ATMT
+    def __init__(self):
+        self.MODEL = 0  # type: int
+        self.YEAR = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        ATM = ATM()
+        ATM.Init(buf, pos)
+        return cls.InitFromObj(ATM)
+
+    @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, ATM):
+        x = ATMT()
+        x._UnPack(ATM)
+        return x
+
+    # ATMT
+    def _UnPack(self, ATM):
+        if ATM is None:
+            return
+        self.MODEL = ATM.MODEL()
+        self.YEAR = ATM.YEAR()
+
+    # ATMT
+    def Pack(self, builder):
+        ATMStart(builder)
+        ATMAddMODEL(builder, self.MODEL)
+        ATMAddYEAR(builder, self.YEAR)
+        ATM = ATMEnd(builder)
+        return ATM

ATM/AtmosphericModelFamily.py

@@ -0,0 +1,75 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Canonical list of atmosphere model families per CCSDS SANA registry.
+# Use the `YEAR` field in the ATM message to specify the variant implementation.
+class AtmosphericModelFamily(object):
+    # OID: 1.3.112.4.57.9.1
+    # COSPAR International Reference Atmosphere
+    # Known years: 1965, 1972, 1986, 1990
+    CIRA_XX = 0
+    # OID: 1.3.112.4.57.9.2
+    # Drag Temperature Model
+    # Known years: 1978, 1994, 2000, 2009, 2012, 2013, 2020
+    DTM_XX = 1
+    # OID: 1.3.112.4.57.9.3
+    # Global Ionosphere-Thermosphere Model
+    # GITM has no specific year versions defined
+    GITM = 2
+    # OID: 1.3.112.4.57.9.4
+    # GOST atmospheric density model
+    # Known version: 2004 (GOST R 25645.166-2004)
+    GOST = 3
+    # OID: 1.3.112.4.57.9.5
+    # Global Reference Atmospheric Model
+    # Known version: 2016
+    GRAM_XX = 4
+    # OID: 1.3.112.4.57.9.6
+    # Harris-Priester empirical model
+    # Known version: 1962
+    HP = 5
+    # OID: 1.3.112.4.57.9.7
+    # Jacchia atmosphere model with HASDM correction overlay
+    # Based on Jacchia 1970 with HASDM (DCA) overlay
+    JAC_HASDM = 6
+    # OID: 1.3.112.4.57.9.8
+    # Jacchia-Gill bi-polynomial interpolation
+    # Interpolates Jacchia 1971
+    JAC_GILL = 7
+    # OID: 1.3.112.4.57.9.9
+    # Jacchia-Bowman empirical model
+    # Known versions: 2006 (JB2006), 2008 (JB2008)
+    JB08 = 8
+    # OID: 1.3.112.4.57.9.10
+    # Jacchia-Roberts analytic model
+    # Known version: 1971
+    JR71 = 9
+    # OID: 1.3.112.4.57.9.11
+    # Jacchia static diffusion models
+    # Known years: 1970, 1971, 1977
+    JXX = 10
+    # OID: 1.3.112.4.57.9.12
+    # Marshall Engineering Thermosphere
+    # Known version: 2007
+    MET_XX = 11
+    # OID: 1.3.112.4.57.9.13
+    # MSIS empirical model
+    # Known version: 1986
+    MSIS_86 = 12
+    # OID: 1.3.112.4.57.9.14
+    # MSISE empirical model with exosphere extension
+    # Known version: 1990
+    MSISE_90 = 13
+    # OID: 1.3.112.4.57.9.15
+    # NRLMSISE empirical model
+    # Known version: 2000 (NRLMSISE-00E)
+    NRLMSIS00E = 14
+    # OID: 1.3.112.4.57.9.16
+    # Thermosphere-Ionosphere Electrodynamic General Circulation Model
+    # Based on TIME-GCM, no version specified
+    TIECGM = 15
+    # OID: 1.3.112.4.57.9.17
+    # U.S. Standard Atmosphere
+    # Known versions: 1962, 1976
+    USSA_XX = 16

BAL/BAL.py

@@ -0,0 +1,222 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Ballistics
+class BAL(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BAL()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBAL(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BALBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x42\x41\x4C", size_prefixed=size_prefixed)
+
+    # BAL
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BAL
+    def COMMAND(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
+
+    # BAL
+    def TRAJECTORY_REQUEST(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
+
+    # BAL
+    def TABLE_REQUEST(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
+
+    # BAL
+    def FIRE_CONTROL(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
+
+    # BAL
+    def PENETRATION_PROJECTILE(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
+
+    # BAL
+    def PENETRATION_ARMOR(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
+
+    # BAL
+    def IMPACT_VELOCITY_MPS(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
+
+    # BAL
+    def IMPACT_ANGLE_DEG(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
+
+def BALStart(builder):
+    builder.StartObject(8)
+
+def Start(builder):
+    BALStart(builder)
+
+def BALAddCOMMAND(builder, COMMAND):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(COMMAND), 0)
+
+def AddCOMMAND(builder, COMMAND):
+    BALAddCOMMAND(builder, COMMAND)
+
+def BALAddTRAJECTORY_REQUEST(builder, TRAJECTORY_REQUEST):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(TRAJECTORY_REQUEST), 0)
+
+def AddTRAJECTORY_REQUEST(builder, TRAJECTORY_REQUEST):
+    BALAddTRAJECTORY_REQUEST(builder, TRAJECTORY_REQUEST)
+
+def BALAddTABLE_REQUEST(builder, TABLE_REQUEST):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(TABLE_REQUEST), 0)
+
+def AddTABLE_REQUEST(builder, TABLE_REQUEST):
+    BALAddTABLE_REQUEST(builder, TABLE_REQUEST)
+
+def BALAddFIRE_CONTROL(builder, FIRE_CONTROL):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(FIRE_CONTROL), 0)
+
+def AddFIRE_CONTROL(builder, FIRE_CONTROL):
+    BALAddFIRE_CONTROL(builder, FIRE_CONTROL)
+
+def BALAddPENETRATION_PROJECTILE(builder, PENETRATION_PROJECTILE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(PENETRATION_PROJECTILE), 0)
+
+def AddPENETRATION_PROJECTILE(builder, PENETRATION_PROJECTILE):
+    BALAddPENETRATION_PROJECTILE(builder, PENETRATION_PROJECTILE)
+
+def BALAddPENETRATION_ARMOR(builder, PENETRATION_ARMOR):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(PENETRATION_ARMOR), 0)
+
+def AddPENETRATION_ARMOR(builder, PENETRATION_ARMOR):
+    BALAddPENETRATION_ARMOR(builder, PENETRATION_ARMOR)
+
+def BALAddIMPACT_VELOCITY_MPS(builder, IMPACT_VELOCITY_MPS):
+    builder.PrependFloat64Slot(6, IMPACT_VELOCITY_MPS, 0.0)
+
+def AddIMPACT_VELOCITY_MPS(builder, IMPACT_VELOCITY_MPS):
+    BALAddIMPACT_VELOCITY_MPS(builder, IMPACT_VELOCITY_MPS)
+
+def BALAddIMPACT_ANGLE_DEG(builder, IMPACT_ANGLE_DEG):
+    builder.PrependFloat64Slot(7, IMPACT_ANGLE_DEG, 0.0)
+
+def AddIMPACT_ANGLE_DEG(builder, IMPACT_ANGLE_DEG):
+    BALAddIMPACT_ANGLE_DEG(builder, IMPACT_ANGLE_DEG)
+
+def BALEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BALEnd(builder)
+
+
+class BALT(object):
+
+    # BALT
+    def __init__(self):
+        self.COMMAND = None  # type: str
+        self.TRAJECTORY_REQUEST = None  # type: str
+        self.TABLE_REQUEST = None  # type: str
+        self.FIRE_CONTROL = None  # type: str
+        self.PENETRATION_PROJECTILE = None  # type: str
+        self.PENETRATION_ARMOR = None  # type: str
+        self.IMPACT_VELOCITY_MPS = 0.0  # type: float
+        self.IMPACT_ANGLE_DEG = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        BAL = BAL()
+        BAL.Init(buf, pos)
+        return cls.InitFromObj(BAL)
+
+    @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, BAL):
+        x = BALT()
+        x._UnPack(BAL)
+        return x
+
+    # BALT
+    def _UnPack(self, BAL):
+        if BAL is None:
+            return
+        self.COMMAND = BAL.COMMAND()
+        self.TRAJECTORY_REQUEST = BAL.TRAJECTORY_REQUEST()
+        self.TABLE_REQUEST = BAL.TABLE_REQUEST()
+        self.FIRE_CONTROL = BAL.FIRE_CONTROL()
+        self.PENETRATION_PROJECTILE = BAL.PENETRATION_PROJECTILE()
+        self.PENETRATION_ARMOR = BAL.PENETRATION_ARMOR()
+        self.IMPACT_VELOCITY_MPS = BAL.IMPACT_VELOCITY_MPS()
+        self.IMPACT_ANGLE_DEG = BAL.IMPACT_ANGLE_DEG()
+
+    # BALT
+    def Pack(self, builder):
+        if self.COMMAND is not None:
+            COMMAND = builder.CreateString(self.COMMAND)
+        if self.TRAJECTORY_REQUEST is not None:
+            TRAJECTORY_REQUEST = builder.CreateString(self.TRAJECTORY_REQUEST)
+        if self.TABLE_REQUEST is not None:
+            TABLE_REQUEST = builder.CreateString(self.TABLE_REQUEST)
+        if self.FIRE_CONTROL is not None:
+            FIRE_CONTROL = builder.CreateString(self.FIRE_CONTROL)
+        if self.PENETRATION_PROJECTILE is not None:
+            PENETRATION_PROJECTILE = builder.CreateString(self.PENETRATION_PROJECTILE)
+        if self.PENETRATION_ARMOR is not None:
+            PENETRATION_ARMOR = builder.CreateString(self.PENETRATION_ARMOR)
+        BALStart(builder)
+        if self.COMMAND is not None:
+            BALAddCOMMAND(builder, COMMAND)
+        if self.TRAJECTORY_REQUEST is not None:
+            BALAddTRAJECTORY_REQUEST(builder, TRAJECTORY_REQUEST)
+        if self.TABLE_REQUEST is not None:
+            BALAddTABLE_REQUEST(builder, TABLE_REQUEST)
+        if self.FIRE_CONTROL is not None:
+            BALAddFIRE_CONTROL(builder, FIRE_CONTROL)
+        if self.PENETRATION_PROJECTILE is not None:
+            BALAddPENETRATION_PROJECTILE(builder, PENETRATION_PROJECTILE)
+        if self.PENETRATION_ARMOR is not None:
+            BALAddPENETRATION_ARMOR(builder, PENETRATION_ARMOR)
+        BALAddIMPACT_VELOCITY_MPS(builder, self.IMPACT_VELOCITY_MPS)
+        BALAddIMPACT_ANGLE_DEG(builder, self.IMPACT_ANGLE_DEG)
+        BAL = BALEnd(builder)
+        return BAL

BAL/BallisticModel.py

@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class BallisticModel(object):
+    POINT_MASS_2D = 0
+    POINT_MASS_3D = 1
+    MODIFIED_POINT_MASS = 2
+    SIX_DOF = 3

BAL/DragModel.py

@@ -0,0 +1,16 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class DragModel(object):
+    G1 = 0
+    G2 = 1
+    G5 = 2
+    G6 = 3
+    G7 = 4
+    G8 = 5
+    GI = 6
+    GL = 7
+    GS = 8
+    RA4 = 9
+    CUSTOM = 10

BAL/PenetrationModel.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class PenetrationModel(object):
+    DE_MARRE = 0
+    THOR = 1
+    ODERMATT = 2
+    ANDERSON = 3
+    BRL = 4

BAL/ProjectileType.py

@@ -0,0 +1,21 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class ProjectileType(object):
+    BALL = 0
+    HOLLOW_POINT = 1
+    BOAT_TAIL = 2
+    ARMOR_PIERCING = 3
+    ARMOR_PIERCING_INCENDIARY = 4
+    TRACER = 5
+    SABOT = 6
+    SUBCALIBER = 7
+    HEAT = 8
+    HESH = 9
+    HE = 10
+    APFSDS = 11
+    ARTILLERY_HE = 12
+    MORTAR = 13
+    GRENADE = 14
+    ROCKET = 15

BAL/StabilizationType.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class StabilizationType(object):
+    SPIN = 0
+    FIN = 1
+    DUAL = 2

BEM/BEM.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()
+
+# Antenna Beam
+class BEM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BEM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBEM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BEMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x42\x45\x4D", size_prefixed=size_prefixed)
+
+    # BEM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BEM
+    def ID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # BEM
+    def BEAM_NAME(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
+
+    # BEM
+    def NOTES(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
+
+    # BEM
+    def BEAM_CONTOURS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # BEM
+    def BEAM_CONTOURSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # BEM
+    def BEAM_CONTOURSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+def BEMStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    BEMStart(builder)
+
+def BEMAddID(builder, ID):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ID), 0)
+
+def AddID(builder, ID):
+    BEMAddID(builder, ID)
+
+def BEMAddBEAM_NAME(builder, BEAM_NAME):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(BEAM_NAME), 0)
+
+def AddBEAM_NAME(builder, BEAM_NAME):
+    BEMAddBEAM_NAME(builder, BEAM_NAME)
+
+def BEMAddNOTES(builder, NOTES):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(NOTES), 0)
+
+def AddNOTES(builder, NOTES):
+    BEMAddNOTES(builder, NOTES)
+
+def BEMAddBEAM_CONTOURS(builder, BEAM_CONTOURS):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(BEAM_CONTOURS), 0)
+
+def AddBEAM_CONTOURS(builder, BEAM_CONTOURS):
+    BEMAddBEAM_CONTOURS(builder, BEAM_CONTOURS)
+
+def BEMStartBEAM_CONTOURSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBEAM_CONTOURSVector(builder, numElems):
+    return BEMStartBEAM_CONTOURSVector(builder, numElems)
+
+def BEMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BEMEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class BEMT(object):
+
+    # BEMT
+    def __init__(self):
+        self.ID = None  # type: str
+        self.BEAM_NAME = None  # type: str
+        self.NOTES = None  # type: str
+        self.BEAM_CONTOURS = None  # type: List[str]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        BEM = BEM()
+        BEM.Init(buf, pos)
+        return cls.InitFromObj(BEM)
+
+    @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, BEM):
+        x = BEMT()
+        x._UnPack(BEM)
+        return x
+
+    # BEMT
+    def _UnPack(self, BEM):
+        if BEM is None:
+            return
+        self.ID = BEM.ID()
+        self.BEAM_NAME = BEM.BEAM_NAME()
+        self.NOTES = BEM.NOTES()
+        if not BEM.BEAM_CONTOURSIsNone():
+            self.BEAM_CONTOURS = []
+            for i in range(BEM.BEAM_CONTOURSLength()):
+                self.BEAM_CONTOURS.append(BEM.BEAM_CONTOURS(i))
+
+    # BEMT
+    def Pack(self, builder):
+        if self.ID is not None:
+            ID = builder.CreateString(self.ID)
+        if self.BEAM_NAME is not None:
+            BEAM_NAME = builder.CreateString(self.BEAM_NAME)
+        if self.NOTES is not None:
+            NOTES = builder.CreateString(self.NOTES)
+        if self.BEAM_CONTOURS is not None:
+            BEAM_CONTOURSlist = []
+            for i in range(len(self.BEAM_CONTOURS)):
+                BEAM_CONTOURSlist.append(builder.CreateString(self.BEAM_CONTOURS[i]))
+            BEMStartBEAM_CONTOURSVector(builder, len(self.BEAM_CONTOURS))
+            for i in reversed(range(len(self.BEAM_CONTOURS))):
+                builder.PrependUOffsetTRelative(BEAM_CONTOURSlist[i])
+            BEAM_CONTOURS = builder.EndVector()
+        BEMStart(builder)
+        if self.ID is not None:
+            BEMAddID(builder, ID)
+        if self.BEAM_NAME is not None:
+            BEMAddBEAM_NAME(builder, BEAM_NAME)
+        if self.NOTES is not None:
+            BEMAddNOTES(builder, NOTES)
+        if self.BEAM_CONTOURS is not None:
+            BEMAddBEAM_CONTOURS(builder, BEAM_CONTOURS)
+        BEM = BEMEnd(builder)
+        return BEM