Ejemplo n.º 1
0
def example5():
    """
    Example 5: Get Elements by Node ID - Level 2
    """

    # this example will demonstate:
    #  - getting the list of elements that share a certain node

    # our model
    import pyNastran
    pkg_path = pyNastran.__path__[0]
    test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
    bdf_filename = os.path.join(test_path, 'solid_bending.bdf')

    # instantiate the model
    from pyNastran.bdf.bdf import BDF
    model = BDF()
    model.read_bdf(bdf_filename, xref=True)
    f = open('junk.out', 'w')

    # given a Node, get the Elements Attached to that Node
    # assume node 55
    # doesnt support 0d/1d elements yet
    nid_to_eids_map = model.get_node_id_to_element_ids_map()
    eids = nid_to_eids_map[55]

    # convert to elements instead of element IDs
    elements = []
    for eid in eids:
        elements.append(model.Element(eid))

    print("eids = %s" % eids)
    print("elements =\n %s" % elements)
Ejemplo n.º 2
0
    def cross_reference(self, model: BDF) -> None:
        """
        Cross links the card so referenced cards can be extracted directly

        Parameters
        ----------
        model : BDF()
            the BDF object

        """
        msg = ', which is required by QBDY2 sid=%s' % self.sid
        self.eid_ref = model.Element(self.eid, msg=msg)
Ejemplo n.º 3
0
    def cross_reference(self, model: BDF) -> None:
        """
        Cross links the card so referenced cards can be extracted directly

        Parameters
        ----------
        model : BDF()
            the BDF object

        """
        msg = ', which is required by QBDY3 sid=%s' % self.sid
        eids = []
        for eid in self.eids:
            eids.append(model.Element(eid, msg=msg))
        self.eids_ref = eids
Ejemplo n.º 4
0
    def cross_reference(self, model: BDF) -> None:
        """
        Cross links the card so referenced cards can be extracted directly

        Parameters
        ----------
        model : BDF()
            the BDF object

        """
        msg = ', which is required by RADBC pid=%s' % self.nodamb
        elems = []
        for eid in self.eids:
            elem = model.Element(eid, msg=msg)
            elems.append(elem)
        self.eids_ref = elems
Ejemplo n.º 5
0
    def test_cbeam_05(self):
        # modification of test_pbeam_05
        model = BDF(debug=False)
        lines = [
            'PBEAM,3,6,2.9,3.5,5.97,0.4,3.14',
            '     , , ,2.0,-4.0',
        ]
        card = model.add_card(lines, 'PBEAM', is_list=False)

        lines = [
            'CBEAM         10       3      1       2      0.01.000000     0.0'
        ]
        model.add_card(lines, 'CBEAM', is_list=False)

        lines = ['MAT1, 6, 1.0e7,,0.3']
        model.add_card(lines, 'MAT1', is_list=False)

        lines = ['GRID,1,,0.,0.,0.']
        model.add_card(lines, 'GRID', is_list=False)

        lines = ['GRID,2,,0.,0.,0.']
        model.add_card(lines, 'GRID', is_list=False)
        model.cross_reference()

        cbeam = model.Element(10)
        #cbeam = model.elements[10]
        #print("Area = ", cbeam.Area())
        #print("I11 = ", cbeam.I11())
        #print("I22 = ", cbeam.I22())
        #print("I12 = ", cbeam.I12())
        #print("J = ", cbeam.J())

        #print("Area = ", cbeam.Area())
        #print("I11 = ", cbeam.I1())
        #print("I22 = ", cbeam.I2())
        #print("I12 = ", cbeam.I12())
        #print("J = ", cbeam.J())
        node_ids = cbeam.node_ids
        assert node_ids == [1, 2], node_ids
        self.assertEqual(cbeam.Area(), 2.9)
        self.assertEqual(cbeam.I11(), 3.5)
        self.assertEqual(cbeam.I22(), 5.97)
        self.assertEqual(cbeam.I12(), 0.4)
        self.assertEqual(cbeam.J(), 3.14)
Ejemplo n.º 6
0
    def test_cbeam_01(self):
        """modification of test_pbeam_05"""
        model = BDF(debug=False)
        lines = [
            'PBEAM,3,6,2.9,3.5,5.97,0.4,3.14',
            '     , , ,2.0,-4.0',
        ]
        model.add_card(lines, 'PBEAM', is_list=False)

        lines = [
            'CBEAM         10       3      1       2      0.01.000000     0.0'
        ]
        model.add_card(lines, 'CBEAM', is_list=False)

        mid = 6
        E = 1.0e7
        G = None
        nu = 0.3
        model.add_mat1(mid, E, G, nu)
        model.add_grid(1, [0., 0., 0.])
        model.add_grid(2, [0., 0., 0.])
        model.cross_reference()

        cbeam = model.Element(10)
        #cbeam = model.elements[10]
        #print("Area = ", cbeam.Area())
        #print("I11 = ", cbeam.I11())
        #print("I22 = ", cbeam.I22())
        #print("I12 = ", cbeam.I12())
        #print("J = ", cbeam.J())

        #print("Area = ", cbeam.Area())
        #print("I11 = ", cbeam.I1())
        #print("I22 = ", cbeam.I2())
        #print("I12 = ", cbeam.I12())
        print("J = ", cbeam.J())
        node_ids = cbeam.node_ids
        assert node_ids == [1, 2], node_ids
        self.assertEqual(cbeam.Area(), 2.9)
        self.assertEqual(cbeam.I11(), 3.5)
        self.assertEqual(cbeam.I22(), 5.97)
        self.assertEqual(cbeam.I12(), 0.4)
        self.assertEqual(cbeam.J(), 3.14)
Ejemplo n.º 7
0
def example7():
    """
    Example 7:  Get Elements by Material ID - Level 2
    """
    # this example will demonstate:
    #  - getting a list of elements that have a certain material

    # our model
    import pyNastran
    pkg_path = pyNastran.__path__[0]
    test_path = os.path.join(pkg_path, '..', 'models', 'sol_101_elements')
    bdf_filename = os.path.join(test_path, 'static_solid_shell_bar.bdf')

    # instantiate the model
    from pyNastran.bdf.bdf import BDF
    model = BDF()
    model.read_bdf(bdf_filename, xref=True)
    f = open('junk.out', 'w')

    # assume you want the eids for material 10
    pid_to_eids_map = model.get_property_id_to_element_ids_map()
    mid_to_pids_map = model.get_material_id_to_property_ids_map()

    pids1 = mid_to_pids_map[1]
    print('pids1 = %s' % pids1)
    ## pids1 = [1, 2, 3, 4, 5]
    eids = []
    for pid in pids1:
        eids += pid_to_eids_map[pid]

    # convert to elements instead of element IDs
    elements = []
    for eid in eids:
        element = model.Element(eid)
        elements.append(element)
        print(str(element).rstrip())
Ejemplo n.º 8
0
def example6():
    """
    Example 6:  Get Elements by Property ID - Level 2
    """
    # this example will demonstate:
    #  - getting a list of elements that have a certain property

    # our model
    import pyNastran
    pkg_path = pyNastran.__path__[0]
    test_path = os.path.join(pkg_path, '..', 'models', 'sol_101_elements')
    bdf_filename = os.path.join(test_path, 'static_solid_shell_bar.bdf')

    # instantiate the model
    from pyNastran.bdf.bdf import BDF
    model = BDF()
    model.read_bdf(bdf_filename, xref=True)
    f = open('junk.out', 'w')

    # Creating a List of Elements based on a Property ID

    # assume pid=1
    pid_to_eids_map = model.get_property_id_to_element_ids_map()
    eids4 = pid_to_eids_map[4]  # PSHELL

    print("eids4 = %s" % eids4)
    ## eids4 = [6, 7, 8, 9, 10, 11]

    # convert to elements instead of element IDs
    elements4 = []
    for eid in eids4:
        elements4.append(model.Element(eid))

    # just to verify
    elem = model.elements[eids4[0]]
    print(elem.pid)
Ejemplo n.º 9
0
class FEMModel:
    """
    Class representing a FEM model which is based on a Nastran bdf file
    and which needs to be converted to a Modelica lumped element model.
    From the Nastran bdf file only CTRIA3 triangular plate elements, CQUAD4
    quadrilateral plate elements and CTETRA four-Sided solid Element are
    imported. The corresponding Modelica lumped element models are CTRIA3.mo,
    CQUAD4.mo and CTETRA.mo  
    """

    count = 0  # How many FEMModel objects are there?

    def __init__(self, NastranFile, meshfile):
        """
        Extend `FEMModel.__init__()` to append required input and output data.
        Keyword arguments:
        NastranFile -- Nastran input filename
        """

        self.NastranFile = NastranFile
        self.model = None
        self.conv_el = []
        self.maxelid = None
        self.NCTRIA3 = None
        self.NCQUAD4 = None
        self.NCTETRA = None
        self.NCHEXA8 = None
        self.IFdict = {}

        self._readNas()
        self._getIF()

        self.con_mat = np.zeros((self.maxelid, self.maxelid))
        self.vol = np.zeros(self.maxelid)
        self.F_mat = np.zeros((self.maxelid, self.maxelid))
        self.meshfile = meshfile
        self.calc_vol()
        self.PlatingT = None
        print "\nTotal volume of nastran file: %3.3e m^3" % np.sum(self.vol)

        FEMModel.count += 1

    def _readNas(self):
        """ Read the nastran file and extract the elements.
        """

        'Create the BDF object'
        print "Start reading Nastran file:"
        print "%s" % os.path.abspath(self.NastranFile)
        self.model = BDF(debug=False)
        self.model.read_bdf(self.NastranFile, xref=True)
        self.conv_el = [(eid, el)
                        for (eid, el) in sorted(self.model.elements.items())
                        if el.type in ['CTRIA3', 'CQUAD4', 'CTETRA', 'CHEXA8']]
        self.maxelid = np.max(self.model.element_ids)

        self.NCTRIA3 = len([(eid, el) for (eid, el) in self.conv_el
                            if el.type == 'CTRIA3'])
        self.NCQUAD4 = len([(eid, el) for (eid, el) in self.conv_el
                            if el.type == 'CQUAD4'])
        self.NCTETRA = len([(eid, el) for (eid, el) in self.conv_el
                            if el.type == 'CTETRA'])
        self.NCHEXA8 = len([(eid, el) for (eid, el) in self.conv_el
                            if el.type == 'CHEXA8'])

        print '-------------------------------'
        print '%-4i elements found in file which can be converted:' % len(
            self.conv_el)
        print '-------------------------------'
        print "%-4i CTRIA3 elements" % self.NCTRIA3
        print "%-4i CQUAD4 elements" % self.NCQUAD4
        print "%-4i CTETRA elements" % self.NCTETRA
        print "%-4i CHEXA8 elements" % self.NCHEXA8
        print '-------------------------------'
        print "Finished reading Nastran file."
        print '-------------------------------\n'

    def _getIF(self):
        """ Get interfaces.
        """
        for spc in self.model.spcs:
            for node in self.model.SPC(spc):
                s1 = str(node).split("SPC")[1]
                nid = int(s1.split()[1])
                ngid = s1.split()[3].rstrip('.')
                if ngid in self.IFdict:
                    self.IFdict[ngid]['nodes'].append(nid)
                else:
                    self.IFdict[ngid] = {'nodes': [nid], 'elements': {}}
        for key in self.IFdict:
            for nid in self.IFdict[key]['nodes']:
                tmp = self.model.get_node_id_to_element_ids_map()[nid]
                for i in tmp:
                    inodes = [node.nid for node in self.model.Element(i).nodes]
                    if np.sum(
                        [inodes.count(x)
                         for x in self.IFdict[key]['nodes']]) > 1:
                        if i not in self.IFdict[key]['elements']:
                            self.IFdict[key]['elements'].setdefault(i, [])
            for eid in self.IFdict[key]['elements']:
                el = self.model.Element(eid)
                elnodes = [node.nid for node in el.nodes]
                if el.type == 'CTRIA3':
                    sides = [[0, 1], [1, 2], [2, 0]]
                if el.type == 'CQUAD4':
                    sides = [[0, 1], [1, 2], [2, 3], [3, 0]]
                for i in range(len(sides)):
                    v1 = elnodes[sides[i][0]]
                    v2 = elnodes[sides[i][1]]
                    if (v1 in self.IFdict[key]['nodes']) and (
                            v2 in self.IFdict[key]['nodes']):
                        self.IFdict[key]['elements'][eid].append([[v1, v2], 0])

        print self.IFdict

    def _connected(self, el_type_1, el_nodes_1, el_type_2, el_nodes_2):
        """
        """
        comb = {
            'CTRIA3CTRIA3': 2,
            'CTRIA3CQUAD4': 2,
            'CTRIA3CTETRA': 2,
            'CTRIA3CHEXA8': 2,
            'CQUAD4CTRIA3': 2,
            'CQUAD4CQUAD4': 2,
            'CQUAD4CTETRA': 2,
            'CQUAD4CHEXA8': 2,
            'CTETRACTRIA3': 2,
            'CTETRACQUAD4': 2,
            'CTETRACTETRA': 3,
            'CTETRACHEXA8': -1,
            'CHEXA8CTRIA3': 2,
            'CHEXA8CQUAD4': 2,
            'CHEXA8CTETRA': -1,
            'CHEXA8CHEXA8': 4,
        }
        mask = el_type_1 + el_type_2
        inters = len(np.intersect1d(el_nodes_1, el_nodes_2))
        if inters == comb[mask]:
            value = True
        else:
            value = False
        return value

    def _get_con(self):
        """
        """
        nid_to_eids_map = self.model.get_node_id_to_element_ids_map()
        for (eid, el) in sorted(self.model.elements.items()):
            con_el = []
            el_type_1 = el.type
            el_nodes_1 = el.node_ids
            con_el_node = []
            for elid in el.node_ids:
                [con_el_node.append(i) for i in nid_to_eids_map[elid]]
            for eid2 in set(con_el_node):
                el_type_2 = self.model.Element(eid2).type
                el_nodes_2 = self.model.Element(eid2).node_ids
                if self._connected(el_type_1, el_nodes_1, el_type_2,
                                   el_nodes_2):
                    con_el.append(eid2)
            for con in con_el:
                self.con_mat[con - 1][eid - 1] = 1
                self.con_mat[eid - 1][con - 1] = 1
        self.ncon = np.count_nonzero(np.triu(self.con_mat))
        print "\nTotal number of internal connections: %i" % (np.count_nonzero(
            self.con_mat))

    def calc_vol(self):
        """
        """
        for (eid, el) in sorted(self.model.elements.items()):
            v, lcar = self._calc_el_vol(el, eid)
            self.vol[eid - 1] = v

    def _calc_el_vol(self, el, eid):
        """
        """
        if (el.type == 'CTRIA3') or (el.type == 'CQUAD4'):
            a = el.Area()
            t = el.Thickness()
            v = a * t * 1e-9
            lcar = np.sqrt((4. / 3.) * np.sqrt(3.) * (a * 1 / 115.))
        if el.type == 'CTETRA':
            v = el.Volume() * 1e-9
            lcar = (v * 3e6 * np.sqrt(2))**(1. / 3.)
        if el.type == 'CHEXA8':
            v = el.Volume() * 1e-9
            lcar = (v * 1.5e6 * np.sqrt(2))**(1. / 3.)
        self.vol[eid - 1] = v
        return (v, lcar)

    def convert(self, verbose=False, PlatingT=None):
        """
        """
        if PlatingT is not None:
            self.PlatingT = PlatingT
            self.Fpl_mat = np.zeros((self.maxelid, self.maxelid))
            print "Adding data for plating thickness of %3.3e" % self.PlatingT
        self._get_con()
        nF = 0
        for (eid1, el1) in self.conv_el:
            if eid1:
                el1 = self.model.elements[eid1]
                (vol, lcar) = self._calc_el_vol(el1, eid1)
                print "\nElement %i evaluated: type=%s, lcar=%f, vol=%e" % (
                    eid1, el1.type, lcar, vol)
                points = self.model.elements[eid1].get_node_positions()
                if (el1.type == "CTRIA3") or (el1.type == "CQUAD4"):
                    points = _rotate_2D(points)
                if (el1.type == "CTETRA") or (el1.type == "CHEXA8"):
                    el13d = True
                    t = None
                else:
                    el13d = False
                    t = el1.Thickness()
                print "Creating mesh..."
                mesh_el(el1.type, points, lcar=lcar, filename=self.meshfile)
                for eid2 in np.arange(1, self.maxelid + 1):
                    if eid2:
                        if self.con_mat[eid1 - 1][eid2 - 1] != 0:
                            n_ids_1 = self.model.elements[eid1].node_ids
                            n_ids_2 = self.model.elements[eid2].node_ids
                            el2 = self.model.elements[eid2]
                            boundary = np.in1d(n_ids_1, n_ids_2)
                            if (el2.type == "CTRIA3") or (el2.type
                                                          == "CQUAD4"):
                                el22d = True
                            else:
                                el22d = False
                            if el13d and el22d:
                                print "3D to 2D connection detected, adjusting boundary."
                                nodes = []
                                for node in n_ids_1:
                                    if node not in n_ids_2:
                                        nodes.append(node)
                                Ftot = 0
                                for node in nodes:
                                    for i in range(len(boundary)):
                                        if n_ids_1[i] == node:
                                            boundary[i] = True
                                    try:
                                        F = FarField(el1.type,
                                                     points,
                                                     boundary,
                                                     lcar,
                                                     0.005,
                                                     self.meshfile,
                                                     thickness=t,
                                                     verbose=verbose)
                                        print "Handling element %i, node %i added, F=%f" % (
                                            eid2, node, F)
                                        Ftot += F
                                    except Exception as e:
                                        print "Handling element %i, F determination failed!" % (
                                            eid2)
                                        print(e)
                                Favg = Ftot / len(nodes)
                                self.F_mat[eid1 - 1][eid2 - 1] = Favg
                                nF += 1
                                print "Handling element %i, done, Favg=%f" % (
                                    eid2, Favg)
                            try:
                                F = FarField(el1.type,
                                             points,
                                             boundary,
                                             lcar,
                                             0.005,
                                             self.meshfile,
                                             thickness=t,
                                             verbose=verbose)
                                self.F_mat[eid1 - 1][eid2 - 1] = F
                                nF += 1
                                print "Step %i, handling element %i, F=%f" % (
                                    nF, eid2, F)
                                if self.PlatingT is not None:
                                    self.Fpl_mat[eid1 -
                                                 1][eid2 -
                                                    1] = (self.PlatingT /
                                                          t) * F
                                    print "Step %i, handling plating element %i, Fpl=%f" % (
                                        nF, eid2,
                                        self.Fpl_mat[eid1 - 1][eid2 - 1])
                            except Exception as e:
                                print "Handling element %i, F determination failed!" % (
                                    eid2)
                                print(e)
                for key in self.IFdict:
                    if eid1 in self.IFdict[key]['elements']:
                        IFbound = self.IFdict[key]['elements'][eid1]
                        for IF in IFbound:
                            edge = IF[0]
                            boundary = np.in1d(n_ids_1, edge)
                            try:
                                F = FarField(el1.type,
                                             points,
                                             boundary,
                                             lcar,
                                             0.005,
                                             self.meshfile,
                                             thickness=t,
                                             verbose=verbose)
                                IF[1] = F
                                print "Handling element %i interface, F=%f" % (
                                    eid1, F)
                                if self.PlatingT is not None:
                                    IF[2] = (self.PlatingT / t) * F
                                    print "Plating element %i interface, Fpl=%f" % (
                                        eid1, IF[2])
                            except Exception as e:
                                print "Handling element %i, interface failed!" % (
                                    eid1)
                                print(e)

        self.vtotal = np.sum(self.vol)
        print '\nTotal converted volume: %e\n' % self.vtotal

    def ExportModelicaFile(self,
                           FileName,
                           WithinStr=None,
                           MaterialStr=None,
                           IFnamedict=None,
                           DiagramStr=None,
                           PlatingStr=None):
        """
        """

        print "Start writing Modelica file:"
        print "%s" % os.path.abspath(FileName)
        'Open the Modelica file buffer for writing'
        f = open(FileName, 'w')
        self.modelname = ntpath.basename(FileName)[:-3]

        'Write Modelica file header'
        if WithinStr is None:
            header = "model %s\n" % self.modelname
        else:
            header = "within %s;\n\n" % WithinStr
            header += "model %s\n" % self.modelname
        header += "   /*\n"
        header += "   This Modelica file is created using the FarFieldConvert python script.\n"
        header += "   Nastran input file: %s\n" % os.path.abspath(
            self.NastranFile)
        header += "   Exported on %s, at %s\n" % (
            datetime.datetime.now().strftime("%d/%m/%Y"),
            datetime.datetime.now().strftime("%H:%M:%S"))
        header += "   The file Contains the following mesh elements converted into lumped elements:\n"
        header += "   %-5i CTRIA3 elements\n" % self.NCTRIA3
        header += "   %-5i CQUAD4 elements\n" % self.NCQUAD4
        header += "   %-5i CTETRA elements\n" % self.NCTETRA
        header += "   %-5i CHEXA8 elements\n\n" % self.NCHEXA8
        header += "   The following %i IF groups were converted from SPC temperature BC's:\n" % len(
            self.IFdict)

        sortedkeys = sorted(map(int, list(self.IFdict.keys())))
        for id in sortedkeys:
            key = str(id)
            if IFnamedict is None:
                header += "   %s: %s \n" % (key, str(self.IFdict[key]))
            else:
                header += "   %s: nodes: %s \n" % (IFnamedict[key]['name'],
                                                   self.IFdict[key]['nodes'])
        if self.PlatingT is not None:
            header += "   A plating is added to the model with a thickness of %f mm\n" % self.PlatingT
            header += "   The heat capacity of this plating is neglected, while parallel conductances are added to the base material.\n"
        header += "   */\n"
        f.write(header)
        f.write("\n")

        'Create material declaration and start temperature statement:'
        Strmat = "   /* Material declaration: */\n"
        if MaterialStr is None:
            Strmat += "   replaceable package Material = ThermalCryogenics.Materials.Unity\n"
            Strmat += "   constrainedby Modelica.ThermalCryogenics.Interfaces.PartialMaterial;\n"
        else:
            if self.PlatingT is None:
                Strmat += "   replaceable package Material = %s\n" % MaterialStr
                Strmat += "   constrainedby Modelica.ThermalCryogenics.Interfaces.PartialMaterial;\n"
            else:
                Strmat += "   replaceable package Material = %s\n" % MaterialStr
                Strmat += "   constrainedby Modelica.ThermalCryogenics.Interfaces.PartialMaterial;\n"
                Strmat += "   replaceable package Plating = %s\n" % PlatingStr
                Strmat += "   constrainedby Modelica.ThermalCryogenics.Interfaces.PartialMaterial;\n"
        f.write(Strmat)
        StrTstart = "   parameter Modelica.SIunits.Temperature Tstart(displayUnit=\"K\") \"Start temperature of part\";\n"
        f.write(StrTstart)
        f.write("\n")

        'Create component statements in mo file'
        f.write('   /* Component section: */\n')
        IFStr = _interfacesection(self, IFnamedict)
        f.write(IFStr)
        ModelStr = _modelsection(self)
        f.write(ModelStr)

        'Create connection equations in mo file'
        f.write('\n')
        self.ConnectStr = _connectsection(self, IFnamedict)
        f.write(self.ConnectStr)

        'Add footer in mo file'
        if DiagramStr is None:
            l = len(self.IFdict) * 50.
            footer = "\n"
            footer += "annotation(Icon(coordinateSystem(initialScale = 0.1),\n"
            footer += "   graphics={\n"
            footer += "      Text(\n"
            footer += "         origin = {0, 0},\n"
            footer += "         lineColor = {0, 0, 255},\n"
            footer += "         extent = {{-150, 140}, {150, 100}},\n"
            footer += "         textString = \"%name\"),\n"
            footer += "      Rectangle(\n"
            footer += "         origin = {0, 0},\n"
            footer += "         extent = {{-100, %.0f}, {100, %.0f}})}),\n" % (
                l, -l)
            footer += "   uses(Modelica(version = \"3.2.2\")));\n"

        else:
            footer = DiagramStr
        footer += "\nend %s;" % self.modelname
        f.write(footer)
        'Close the mo file buffer'
        f.close()
        print "Finished"
Ejemplo n.º 10
0
 def cross_reference(self, model: BDF) -> None:
     self.eid_ref = model.Element(self.eid)
     self.eids_ref = model.Elements(self.eids)
    x = float(gpos[0])
    y = float(gpos[1])
    z = float(gpos[2])
    Coord.append(x)
    Coord.append(y)
    Coord.append(z)
    test = points.InsertNextPoint(*Coord)
    Color.InsertTuple1(test, 0)
    nidMap[nid] = i
    i = i + 1
grid.SetPoints(points)

for (eid, element) in model.elements.iteritems():

    if isinstance(element, CONM2):
        exmcon = model.Element(eid)
        val = str(exmcon)
        val.strip()
        mcon = val.strip().split()
        g = (int(mcon[2]))
        mconvert = vtk.vtkVertex()
        mconvert.GetPointIds().SetId(0, nidMap[g])
        Mconcell = grid.InsertNextCell(mconvert.GetCellType(),
                                       mconvert.GetPointIds())
        Color.InsertTuple1(Mconcell, 1)

k = 0
for (eid, element) in model.elements.iteritems():
    EidMap[eid] = k
    if isinstance(element, CBUSH) or isinstance(element, CBEAM):
        exbar = model.Element(eid)