pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
geom2.py
Go to the documentation of this file.
00001 ## GNU Lesser General Public License
00002 ## 
00003 ## Program pyNastran - a python interface to NASTRAN files
00004 ## Copyright (C) 2011-2012  Steven Doyle, Al Danial
00005 ## 
00006 ## Authors and copyright holders of pyNastran
00007 ## Steven Doyle <mesheb82@gmail.com>
00008 ## Al Danial    <al.danial@gmail.com>
00009 ## 
00010 ## This file is part of pyNastran.
00011 ## 
00012 ## pyNastran is free software: you can redistribute it and/or modify
00013 ## it under the terms of the GNU Lesser General Public License as published by
00014 ## the Free Software Foundation, either version 3 of the License, or
00015 ## (at your option) any later version.
00016 ## 
00017 ## pyNastran is distributed in the hope that it will be useful,
00018 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 ## GNU General Public License for more details.
00021 ## 
00022 ## You should have received a copy of the GNU Lesser General Public License
00023 ## along with pyNastran.  If not, see <http://www.gnu.org/licenses/>.
00024 ## 
00025 # pylint: disable=E1101,C0103,R0902,R0904,R0914
00026 import sys
00027 from struct import unpack
00028 
00029 from pyNastran.bdf.cards.elements.elements import CGAP
00030 from pyNastran.bdf.cards.elements.damper import (CDAMP1, CDAMP2, CDAMP3,
00031                                                  CDAMP4, CDAMP5, CVISC)
00032 from pyNastran.bdf.cards.elements.springs import CELAS1, CELAS2, CELAS3, CELAS4
00033 from pyNastran.bdf.cards.elements.shell import (CTRIA3, CQUAD4, CTRIA6,
00034                                                 CQUADR, CQUAD8, CQUAD, CQUADX,
00035                                                 CSHEAR)
00036 from pyNastran.bdf.cards.elements.bars import (CROD, CBAR, CTUBE, CONROD,
00037                                                CBEAM)
00038 from pyNastran.bdf.cards.elements.mass import (CONM1, CONM2, CMASS1, CMASS2,
00039                                                CMASS3, CMASS4)
00040 from pyNastran.bdf.cards.elements.solid import (CTETRA4, CTETRA10, CPENTA6,
00041                                                 CPENTA15, CHEXA8, CHEXA20)
00042 from pyNastran.bdf.cards.thermal.thermal import CHBDYG, CONV #, CONVM, CHBDYP
00043 from pyNastran.bdf.cards.nodes           import SPOINTs
00044 
00045 class Geometry2(object):
00046     def readTable_Geom2(self):
00047         self.iTableMap = {
00048            (2408,24,180):    self.readCBAR,    # record 8
00049            (4001,40,275):    self.readCBARAO,  # record 9  - not done
00050            (5408,54,261):    self.readCBEAM,   # record 10
00051            (11401,114,9016): self.readCBEAMP,  # record 11 - not done
00052            (4601,46,298):    self.readCBEND,   # record 12 - not done
00053            (5608,56,218):    self.readCBUSH1D, # record 14 - not done
00054            (2315,23,146):    self.readCCONE,   # record 15 - not done
00055            (201,2,69):       self.readCDAMP1,  # record 16
00056            (301,3,70):       self.readCDAMP2,  # record 17
00057            (401,4,71):       self.readCDAMP3,  # record 18
00058            (501,5,72):       self.readCDAMP4,  # record 19
00059            (10608,106,404):  self.readCDAMP5,  # record 20
00060            (601,6,73):       self.readCELAS1,  # record 29
00061            (701,7,74):       self.readCELAS2,  # record 30
00062            (801,8,75):       self.readCELAS3,  # record 31
00063            (901,9,76):       self.readCELAS4,  # record 32
00064           #(8515,85,209):    self.readCFLUID2, # record 35 - not done
00065           #(8615,86,210):    self.readCFLUID3, # record 36 - not done
00066           #(8715,87,211):    self.readCFLUID4, # record 37 - not done
00067            (1908,19,104):    self.readCGAP,    # record 39 - buggy
00068 
00069            (10808,108,406):  self.readCHBDYG,   # record 43
00070            (10908,109,407):  self.readCHBDYP,   # record 44 - not done
00071            (7308,73,253):    self.readCHEXA,    # record 45
00072            (1001,10,65):     self.readCMASS1,   # record 51
00073            (1101,11,66):     self.readCMASS2,   # record 52
00074            (1201,12,67):     self.readCMASS3,   # record 53
00075            (1301,13,68):     self.readCMASS4,   # record 54
00076            (2508,25,0):      self.readCMFREE,   # record 55 - not done
00077            (1401,14,63):     self.readCONM1,    # record 56 - not done
00078            (1501,15,64):     self.readCONM2,    # record 57
00079            (1601,16,47):     self.readCONROD,   # record 58
00080            (12701,127,408):  self.readCONV,     # record 59 - not tested
00081            (8908,89,422):    self.readCONVM,    # record 60 - not tested
00082            (4108,41,280):    self.readCPENTA,   # record 62
00083 
00084            (9108,91,507):    self.readCQUAD,    # record 68 - not tested
00085            (2958,51,177):    self.readCQUAD4,   # record 69 - maybe buggy on theta/Mcsid field
00086            (13900,139,9989): self.readCQUAD4,   # record 70 - maybe buggy on theta/Mcsid field
00087            (4701,47,326):    self.readCQUAD8,   # record 71 - maybe buggy on theta/Mcsid field
00088            (8009,80,367):    self.readCQUADR,   # record 74 - not tested
00089            (9008,90,508):    self.readCQUADX,   # record 75 - not tested
00090 
00091            (3001,30,48):     self.readCROD,     # record 80
00092           #(12201,122,9013): self.readCTETP,    # record 86 - not done
00093            (5508,55,217):    self.readCTETRA,   # record 87
00094            (5959,59,282):    self.readCTRIA3,   # record 93 - maybe buggy on theta/Mcsid field
00095            (4801,48,327):    self.readCTRIA6,   # record 95 - buggy
00096            (9200,92,385):    self.readCTRIAR,   # record 98  - not done
00097            (6108,61,107):    self.readCTRIAX6,  # record 100 - not done
00098            (3701,37,49):     self.readCTUBE,    # record 103
00099            (3901,39, 50):     self.readCVISC,   # record 104 - not done
00100           #(5201,52,11):      self.readPLOTEL,  # record 114 - not done
00101            (5551,49,105):    self.readSPOINT,   # record 118
00102           #(11601,116,9942):  self.readVUBEAM,  # record 119 - not done
00103           #(2608, 26, 60)
00104         }
00105         self.readRecordTable('GEOM2')
00106 
00107     def readTable_Geom2S(self):
00108         self.readTable_Geom2()
00109         #self.iTableMap = {
00110         #                 }
00111         #self.readRecordTable('GEOM2S')
00112 
00113     def readFake(self,data):
00114         pass
00115 
00116     def addOp2Element(self,elem):
00117         self.addElement(elem,allowOverwrites=True)
00118 
00119 # 1-AEROQ4 (???)
00120 # AEROT3   (???)
00121 # 1-BEAMAERO (1701,17,0)
00122 # 2-CAABSF (2708,27,59)
00123 # 3-CAXIF2 (2108,21,224)
00124 # 4-CAXIF3 (2208,22,225)
00125 # 5-CAXIF4 (2308,23,226)
00126 
00127     def readCBAR(self,data):
00128         """
00129         CBAR(2408,24,180) - the marker for Record 8
00130         """
00131         #print "reading CBAR"
00132         n = 0
00133         nEntries = len(data)//64
00134         for i in xrange(nEntries):
00135             eData = data[n:n+64] # 16*4
00136             f, = unpack(b'i',eData[28:32])
00137             #print "len(eData) = %s" %(len(eData))
00138             if   f==0:
00139                 out = unpack(b'iiiifffiiiffffff',eData)
00140                 (eid,pid,ga,gb,x1,x2,x3, f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00141                 dataIn = [[eid,pid,ga,gb,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],
00142                           [f,x1,x2,x3]]
00143             elif f==1:
00144                 out = unpack(b'iiiifffiiiffffff',eData)
00145                 (eid,pid,ga,gb,x1,x2,x3,f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00146                 dataIn = [[eid,pid,ga,gb,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],
00147                           [f,x1,x2,x3]]
00148             elif f==2:
00149                 out = unpack(b'iiiiiiifiiffffff',eData)
00150                 (eid,pid,ga,gb,g0,junk,junk,f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00151                 dataIn = [[eid,pid,ga,gb,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],[f,g0]]
00152             else:
00153                 raise RuntimeError('invalid f value...f=%s' %(f))
00154             ###
00155             elem = CBAR(None,dataIn)
00156             self.addOp2Element(elem)
00157             n+=64
00158         ###
00159         data = data[n:]
00160 
00161     def readCBARAO(self,data):
00162         """
00163         CBARAO(4001,40,275) - the marker for Record 9
00164         """
00165         self.skippedCardsFile.write('skipping CBARAO in GEOM2\n')
00166 
00167     def readCBEAM(self,data):
00168         """
00169         CBEAM(5408,54,261) - the marker for Record 10
00170         """
00171         #print "reading CBEAM"
00172         n = 0
00173         nEntries = len(data)//72
00174         for i in xrange(nEntries):
00175             eData = data[n:n+72] # 18*4
00176             f, = unpack(b'i',eData[40:44])
00177             #print "f = ",f
00178             #print "len(eData) = %s" %(len(eData))
00179             if   f==0: # basic cid
00180                 out = unpack(b'iiiiiifffiiiffffff',eData)
00181                 (eid,pid,ga,gb,sa,sb,x1,x2,x3,f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00182                 dataIn = [[eid,pid,ga,gb,sa,sb, pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],
00183                           [f,x1,x2,x3]]
00184             elif f==1: # global cid
00185                 out = unpack(b'iiiiiifffiiiffffff',eData)
00186                 (eid,pid,ga,gb,sa,sb,x1,x2,x3,f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00187                 dataIn = [[eid,pid,ga,gb,sa,sb, pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],
00188                           [f,x1,x2,x3]]
00189             elif f==2: # grid option
00190                 out = unpack(b'iiiiiiiiiiiiffffff',eData)
00191                 (eid,pid,ga,gb,sa,sb,g0,xx,xx,f,pa,pb,w1a,w2a,w3a,w1b,w2b,w3b) = out
00192                 dataIn = [[eid,pid,ga,gb,sa,sb, pa,pb,w1a,w2a,w3a,w1b,w2b,w3b],
00193                           [f,g0]]
00194             else:
00195                 raise RuntimeError('invalid f value...f=%s' %(f))
00196             ###
00197             elem = CBEAM(None,dataIn)
00198             self.addOp2Element(elem)
00199             n+=72
00200         ###
00201         data = data[n:]
00202 
00203     def readCBEAMP(self,data):
00204         """
00205         CBEAMP(11401,114,9016) - the marker for Record 11
00206         """
00207         self.skippedCardsFile.write('skipping CBEAMP in GEOM2\n')
00208 
00209     def readCBEND(self,data):
00210         """
00211         CBEND(4601,46,298) - the marker for Record 12
00212         """
00213         self.skippedCardsFile.write('skipping CBEND in GEOM2\n')
00214 
00215     def readCBUSH(self,data):
00216         """
00217         CBUSH(2608,26,60) - the marker for Record 13
00218         """
00219         self.skippedCardsFile.write('skipping CBUSH in GEOM2\n')
00220 
00221     def readCBUSH1D(self,data):
00222         """
00223         CBUSH1D(5608,56,218) - the marker for Record 14
00224         """
00225         self.skippedCardsFile.write('skipping CBUSH1D in GEOM2\n')
00226 
00227     def readCCONE(self,data):
00228         """
00229         CCONE(2315,23,0) - the marker for Record 15
00230         """
00231         self.skippedCardsFile.write('skipping CCONE in GEOM2\n')
00232 
00233     def readCDAMP1(self,data):
00234         """
00235         CDAMP1(201,2,69) - the marker for Record 16
00236         """
00237         #print "reading CDAMP1"
00238         n = 0
00239         nEntries = len(data)//24
00240         for i in xrange(nEntries):
00241             eData = data[n:n+24] # 6*4
00242             out = unpack(b'iiiiii',eData)
00243             (eid,pid,g1,g2,c1,c2) = out
00244             elem = CDAMP1(None,out)
00245             self.addOp2Element(elem)
00246             n+=24
00247         ###
00248         data = data[n:]
00249 
00250     def readCDAMP2(self,data):
00251         """
00252         CDAMP2(301,3,70) - the marker for Record 17
00253         """
00254         #print "reading CDAMP2"
00255         n = 0
00256         nEntries = len(data)//24
00257         for i in xrange(nEntries):
00258             eData = data[n:n+24] # 6*4
00259             out = unpack(b'ifiiii',eData)
00260             (eid,b,g1,g2,c1,c2) = out
00261             elem = CDAMP2(None,out)
00262             self.addOp2Element(elem)
00263             n+=24
00264         ###
00265         data = data[n:]
00266 
00267     def readCDAMP3(self,data):
00268         """
00269         CDAMP3(401,4,71) - the marker for Record 18
00270         """
00271         #print "reading CDAMP3"
00272         n = 0
00273         nEntries = len(data)//16
00274         for i in xrange(nEntries):
00275             eData = data[n:n+16] # 4*4
00276             out = unpack(b'iiii',eData)
00277             (eid,pid,s1,s2) = out
00278             elem = CDAMP3(None,out)
00279             self.addOp2Element(elem)
00280             n+=16
00281         ###
00282         data = data[n:]
00283 
00284     def readCDAMP4(self,data):
00285         """
00286         CDAMP4(501,5,72) - the marker for Record 19
00287         """
00288         #print "reading CDAMP4"
00289         n = 0
00290         nEntries = len(data)//16
00291         for i in xrange(nEntries):
00292             eData = data[n:n+16] # 4*4
00293             out = unpack(b'ifii',eData)
00294             (eid,b,s1,s2) = out
00295             elem = CDAMP4(None,out)
00296             self.addOp2Element(elem)
00297             n+=16
00298         ###
00299         data = data[n:]
00300 
00301     def readCDAMP5(self,data):
00302         """
00303         CDAMP5(10608,106,404) - the marker for Record 20
00304         """
00305         #print "reading CDAMP5"
00306         n = 0
00307         nEntries = len(data)//16
00308         for i in xrange(nEntries):
00309             eData = data[n:n+16] # 4*4
00310             out = unpack(b'iiii',eData)
00311             (eid,pid,s1,s2) = out
00312             elem = CDAMP5(None,out)
00313             self.addOp2Element(elem)
00314             n+=16
00315         ###
00316         data = data[n:]
00317 
00318 # CDUM2
00319 # CDUM3
00320 # CDUM4
00321 # CDUM5
00322 # CDUM6
00323 # CDUM7
00324 # CDUM8
00325 # CDUM9
00326 
00327     def readCELAS1(self,data):
00328         """
00329         CELAS1(601,6,73) - the marker for Record 29
00330         """
00331         #print "reading CELAS1"
00332         while len(data)>=24: # 6*4
00333             eData = data[:24]
00334             data  = data[24:]
00335             out = unpack(b'iiiiii',eData)
00336             (eid,pid,g1,g2,c1,c2) = out
00337             elem = CELAS1(None,out)
00338             self.addOp2Element(elem)
00339         ###
00340 
00341     def readCELAS2(self,data):
00342         """
00343         CELAS2(701,7,74) - the marker for Record 30
00344         """
00345         #print "reading CELAS2"
00346         while len(data)>=32: # 8*4
00347             eData = data[:32]
00348             data  = data[32:]
00349             out = unpack(b'ifiiiiff',eData)
00350             (eid,k,g1,g2,c1,c2,ge,s) = out
00351             elem = CELAS2(None,out)
00352             self.addOp2Element(elem)
00353         ###
00354 
00355     def readCELAS3(self,data):
00356         """
00357         CELAS3(801,8,75) - the marker for Record 31
00358         """
00359         #print "reading CELAS3"
00360         while len(data)>=16: # 4*4
00361             eData = data[:16]
00362             data  = data[16:]
00363             out = unpack(b'iiii',eData)
00364             (eid,pid,s1,s2) = out
00365             elem = CELAS3(None,out)
00366             self.addOp2Element(elem)
00367         ###
00368 
00369     def readCELAS4(self,data):
00370         """
00371         CELAS4(901,9,76) - the marker for Record 32
00372         """
00373         #print "reading CELAS4"
00374         n = 0
00375         nEntries = len(data)//16
00376         for i in xrange(nEntries):
00377             eData = data[n:n+16] # 4*4
00378             out = unpack(b'ifii',eData)
00379             (eid,k,s1,s2) = out
00380             elem = CELAS4(None,out)
00381             self.addOp2Element(elem)
00382             n+=16
00383         ###
00384         data = data[n:]
00385 
00386 # CFAST
00387 # CFASTP
00388 # CFLUID2
00389 # CFLUID3
00390 # CFLUID4
00391 # CINT
00392 
00393     def readCGAP(self,data):
00394         """
00395         CGAP(1908,19,104) - the marker for Record 39
00396         """
00397         #print "reading CGAP"
00398         n = 0
00399         nEntries = len(data)//36
00400         for i in xrange(nEntries):
00401             eData = data[n:n+36] # 9*4
00402             out = unpack(b'iiiifffii',eData)
00403             (eid,pid,ga,gb,x1,x2,x3,f,cid) = out # f=0,1
00404             g0 = None
00405             f2, = unpack(b'i',eData[28:32])
00406             assert f==f2,'f=%s f2=%s' %(f,f2)
00407             if f==2:
00408                 g0 = unpack(b'i',eData[16:20])
00409                 x1 = None
00410                 x2 = None
00411                 x3 = None
00412             
00413             dataIn = [eid,pid,ga,gb,g0,x1,x2,x3,cid]
00414             elem = CGAP(None,dataIn)
00415             self.addOp2Element(elem)
00416             n+=36
00417         ###
00418         data = data[n:]
00419 
00420 # CHACAB
00421 # CHACBR
00422 # CHBDYE
00423 # CHBDYG
00424 
00425     def readCHBDYG(self,data):
00426         """
00427         CHBDYG(10808,108,406) - the marker for Record 43
00428         """
00429         return
00430         #print "reading CHBDYG"
00431         while len(data)>=64: # 16*4
00432             eData = data[:64]
00433             data  = data[64:]
00434             (eid,blank,Type,iviewf,iviewb,radmidf,radmidb,blank2,
00435                       g1,g2,g3,g4,g5,g6,g7,g8) = unpack(b'iiiiiiiiiiiiiiii',eData)
00436             dataIn = [eid,Type,iviewf,iviewb,radmidf,radmidb,
00437                       g1,g2,g3,g4,g5,g6,g7,g8]
00438             elem = CHBDYG(None,dataIn)
00439             self.addOp2Element(elem)
00440         ###
00441 
00442     def readCHBDYP(self,data):
00443         self.skippedCardsFile.write('skipping CHBDYP in GEOM2\n')
00444 
00445     def readCHEXA(self,data):
00446         """
00447         CHEXA(7308,73,253) - the marker for Record 45
00448         """
00449         #print "reading CHEXA"
00450         while len(data)>=88: # 22*4
00451             eData = data[:88]
00452             data  = data[88:]
00453             out = unpack(b'iiiiiiiiiiiiiiiiiiiiii',eData)
00454             (eid,pid,g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,
00455              g11,g12,g13,g14,g15,g16,g17,g18,g19,g20) = out
00456 
00457             dataIn   = [eid,pid,g1,g2,g3,g4,g5,g6,g7,g8,]
00458             bigNodes = [g9,g10,g11,g12,g13,g14,g15,g16,g17,g18,g19,g20]
00459             if sum(bigNodes)>0:
00460                 elem = CHEXA20(None,dataIn+bigNodes)
00461             else:
00462                 elem = CHEXA8(None,dataIn)
00463             self.addOp2Element(elem)
00464         ###
00465 
00466 # CHEXA20F
00467 # CHEXAFD
00468 # CHEXAL
00469 # CHEXP
00470 # CHEXPR
00471 
00472     def readCMASS1(self,data):
00473         """
00474         CMASS1(1001,10,65) - the marker for Record 51
00475         """
00476         #print "reading CMASS1"
00477         n = 0
00478         nEntries = len(data)//24
00479         for i in xrange(nEntries):
00480             eData = data[n:n+24] # 6*4
00481             out = unpack(b'iiiiii',eData)
00482             #(eid,pid,g1,g2,c1,c2) = out
00483             elem = CMASS1(None,out)
00484             self.addOp2Element(elem)
00485             n+=24
00486         ###
00487         data = data[n:]
00488 
00489     def readCMASS2(self,data):
00490         """
00491         CMASS2(1101,11,66) - the marker for Record 52
00492         """
00493         #print "reading CMASS2"
00494         n = 0
00495         nEntries = len(data)//24
00496         for i in xrange(nEntries):
00497             eData = data[n:n+24] # 6*4
00498             out = unpack(b'ifiiii',eData)
00499             #(eid,m,g1,g2,c1,c2) = out
00500             elem = CMASS2(None,out)
00501             self.addOp2Element(elem)
00502             n+=24
00503         ###
00504         data = data[n:]
00505 
00506     def readCMASS3(self,data):
00507         """
00508         CMASS3(1201,12,67) - the marker for Record 53
00509         """
00510         #print "reading CMASS3"
00511         n = 0
00512         nEntries = len(data)//16
00513         for i in xrange(nEntries):
00514             eData = data[n:n+16] # 4*4
00515             out = unpack(b'iiii',eData)
00516             #(eid,pid,s1,s2) = out
00517             elem = CMASS3(None,out)
00518             self.addOp2Element(elem)
00519             n+=16
00520         ###
00521         data = data[n:]
00522 
00523     def readCMASS4(self,data):
00524         """
00525         CMASS4(1301,13,68) - the marker for Record 54
00526         """
00527         #print "reading CMASS4"
00528         n = 0
00529         nEntries = len(data)//16
00530         for i in xrange(nEntries):
00531             eData = data[n:n+16] # 4*4
00532             out = unpack(b'ifii',eData)
00533             #(eid,m,s1,s2) = out
00534             elem = CMASS4(None,out)
00535             self.addOp2Element(elem)
00536             n+=16
00537         ###
00538         data = data[n:]
00539 
00540     def readCMFREE(self,data):
00541         """
00542         CMFREE(2508,25,0) - the marker for Record 55
00543         """
00544         self.skippedCardsFile.write('skipping CMFREE in GEOM2\n')
00545 
00546     def readCONM1(self,data):
00547         """
00548         CONM1(1401,14,63) - the marker for Record 56
00549         """
00550         #print "reading CONM1"
00551         n = 0
00552         nEntries = len(data)//96
00553         for i in xrange(nEntries):
00554             eData = data[n:n+96] # 24*4
00555             out = unpack(b'iiifffffffffffffffffffff',eData)
00556             (eid,g,cid,m1, m2a,m2b, m3a,m3b,m3c, m4a,m4b,m4c,m4d,
00557              m5a,m5b,m5c,m5d,m5e,  m6a,m6b,m6c,m6d,m6e,m6f) = out
00558             elem = CONM1(None,out)
00559             self.addOp2Element(elem)
00560             n+=96
00561         ###
00562         data  = data[n:]
00563         
00564     def readCONM2(self,data):
00565         """
00566         CONM2(1501,15,64) - the marker for Record 57
00567         """
00568         #print "reading CONM2"
00569         while len(data)>=52: # 13*4
00570             eData = data[:52]
00571             data  = data[52:]
00572             out = unpack(b'iiiffffffffff',eData)
00573             (eid,g,cid,m,x1,x2,x3,i1,i2a,i2b,i3a,i3b,i3c) = out
00574             elem = CONM2(None,out)
00575             self.addOp2Element(elem)
00576         ###
00577 
00578 
00579     def readCONROD(self,data):
00580         """
00581         CONROD(1601,16,47) - the marker for Record 58
00582         """
00583         #print "reading CONROD"
00584         while len(data)>=32: # 8*4
00585             eData = data[:32]
00586             data  = data[32:]
00587             out = unpack(b'iiiiffff',eData)
00588             (eid,n1,n2,mid,a,j,c,nsm) = out
00589             elem = CONROD(None,out)
00590             self.addOp2Element(elem)
00591         ###
00592 
00593     def readCONV(self,data):
00594         """
00595         CONV(12701,127,408) - the marker for Record 59
00596         """
00597         #print "reading CONV"
00598         return
00599         while len(data)>=80: # 20*4
00600             eData = data[:80]
00601             data  = data[80:]
00602             out = unpack(b'iiiiiiiiiiiiffffffff',eData)
00603             (eid,pconID,flmnd,cntrlnd,
00604              ta1,ta2,ta3,ta5,ta6,ta7,ta8,
00605              wt1,wt2,wt3,wt5,wt6,wt7,wt8) = out
00606             dataIn = [eid,pconID,flmnd,cntrlnd,
00607                       [ta1,ta2,ta3,ta5,ta6,ta7,ta8],
00608                       [wt1,wt2,wt3,wt5,wt6,wt7,wt8]]
00609             elem = CONV(None,dataIn)
00610             self.addOp2Element(elem)
00611         ###
00612 
00613     def readCONVM(self,data):
00614         """
00615         CONVM(8908,89,422) - the marker for Record 60
00616         """
00617         #print "reading CONVM"
00618         return
00619         while len(data)>=28: # 7*4
00620             eData = data[:28]
00621             data  = data[28:]
00622             out = unpack(b'iiiiiii',eData)
00623             (eid,pconID,flmnd,cntrlnd,
00624              [ta1,ta2,ta3]) = out
00625             dataIn = [eid,pconID,flmnd,cntrlnd,
00626                       [ta1,ta2,ta3]]
00627             elem = CONVM(None,dataIn)
00628             self.addOp2Element(elem)
00629         ###
00630 
00631 # CPENP
00632 
00633     def readCPENTA(self,data):
00634         """
00635         CPENTA(4108,41,280) - the marker for Record 62
00636         """
00637         #print "reading CPENTA"
00638         n = 0
00639         nEntries = len(data)//68
00640         for i in xrange(nEntries):
00641             eData = data[n:n+68] # 17*4
00642             out = unpack(b'iiiiiiiiiiiiiiiii',eData)
00643             (eid,pid,g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,
00644              g11,g12,g13,g14,g15) = out
00645             
00646             dataIn   = [eid,pid,g1,g2,g3,g4,g5,g6]
00647             bigNodes = [g7,g8,g9,g10,g11,g12,g13,g14,g15]
00648             if sum(bigNodes)>0:
00649                 elem = CPENTA15(None,dataIn+bigNodes)
00650             else:
00651                 elem = CPENTA6(None,dataIn)
00652             self.addOp2Element(elem)
00653             n+=68
00654         ###
00655         data  = data[n:]
00656 
00657 # CPENPR
00658 # CPENT15F
00659 # CPENT6FD
00660 # CQDX4FD
00661 # CQDX9FD
00662 
00663 
00664     def readCQUAD(self,data):
00665         """
00666         CQUAD(9108,91,507)  - the marker for Record 68
00667         """
00668         #print "reading CQUAD"
00669         self.runCQUAD(data,CQUAD)
00670         
00671     def runCQUAD(self,data,Element):
00672         """common method for CQUAD, CQUADX"""
00673         n = 0
00674         nEntries = len(data)//44 # 11*4
00675         for i in xrange(nEntries):
00676             eData = data[n:n+44]
00677             (eid,pid,n1,n2,n3,n4,n5,n6,n7,n8,n9) = unpack(b'iiiiiiiiiii',eData)
00678             #print "eid=%s pid=%s n1=%s n2=%s n3=%s n4=%s theta=%s zoffs=%s tflag=%s t1=%s t2=%s t3=%s t4=%s" %(eid,pid,n1,n2,n3,n4,theta,zoffs,tflag,t1,t2,t3,t4)
00679             #dataInit = [eid,pid,n1,n2,n3,n4,theta,zoffs,tflag,t1,t2,t3,t4]
00680             data = [eid,pid,n1,n2,n3,n4,n5,n6,n7,n8,n9]
00681             elem = Element(None,data)
00682             self.addOp2Element(elem)
00683             n+=44
00684         ###
00685         data  = data[n:]
00686 
00687     def readCQUAD4(self,data):
00688         """
00689         CQUAD4(2958,51,177)    - the marker for Record 69
00690         CQUAD4(13900,139,9989) - the marker for Record 70
00691         """
00692         #print "reading CQUAD4"
00693         self.runCQUAD4(data,CQUAD4)
00694 
00695     def runCQUAD4(self,data,Element):
00696         """
00697         common method for CQUAD4, CQUADR
00698         """
00699         n = 0
00700         nEntries = len(data)//56
00701         for i in xrange(nEntries):
00702             eData = data[n:n+56] # 14*4
00703             (eid,pid,n1,n2,n3,n4,theta,zoffs,blank,tflag,t1,t2,t3,t4) = unpack(b'iiiiiiffiiffff',eData)
00704             #print "eid=%s pid=%s n1=%s n2=%s n3=%s n4=%s theta=%s zoffs=%s blank=%s tflag=%s t1=%s t2=%s t3=%s t4=%s" %(eid,pid,n1,n2,n3,n4,theta,zoffs,blank,tflag,t1,t2,t3,t4)
00705             dataInit = [eid,pid,n1,n2,n3,n4,theta,zoffs,tflag,t1,t2,t3,t4]
00706             elem = Element(None,dataInit)
00707             self.addOp2Element(elem)
00708             n+=56
00709         ###
00710         data  = data[n:]
00711 
00712 # CQUAD4FD
00713 
00714     def readCQUAD8(self,data):
00715         """
00716         CQUAD8(4701,47,326)  - the marker for Record 71
00717         @warning inconsistent with dmap manual
00718         """
00719         #print "reading CQUAD8"
00720         return
00721         n = 0
00722         nEntries = len(data)//64 # 17*4
00723         for i in xrange(nEntries):
00724             eData = data[n:n+64]
00725             out = unpack(b'iiiiiiiiiifffffi',eData)
00726             (eid,pid,n1,n2,n3,n4,n5,n6,n7,n8,t1,t2,t3,t4,theta,tflag) = out
00727             #print "eid=%s pid=%s n1=%s n2=%s n3=%s n4=%s theta=%s zoffs=%s tflag=%s t1=%s t2=%s t3=%s t4=%s" %(eid,pid,n1,n2,n3,n4,theta,zoffs,tflag,t1,t2,t3,t4)
00728             #dataInit = [eid,pid,n1,n2,n3,n4,theta,zoffs,tflag,t1,t2,t3,t4]
00729             elem = CQUAD8(None,out)
00730             self.addOp2Element(elem)
00731             n+=64
00732         ###
00733         data  = data[n:]
00734 
00735 
00736 # CQUAD9FD
00737 # CQUADP
00738 
00739     def readCQUADR(self,data):
00740         """
00741         CQUADR(8009,80,367)  - the marker for Record 74
00742         """
00743         #print "reading CQUADR"
00744         self.runCQUAD4(data,CQUADR)
00745 
00746     def readCQUADX(self,data):
00747         """
00748         CQUADX(9008,90,508)  - the marker for Record 75
00749         """
00750         #print "reading CQUADX"
00751         self.runCQUAD4(data,CQUADX)
00752 
00753 # CRBAR
00754 # CRBE1
00755 # CRBE3
00756 # CRJOINT
00757 
00758     def readCROD(self,data):
00759         """
00760         CROD(3001,30,48)    - the marker for Record 80
00761         """
00762         #print "reading CROD"
00763         n = 0
00764         nEntries = len(data)//16 # 4*4
00765         for i in xrange(nEntries):
00766             eData = data[n:n+16]
00767             out = unpack(b'iiii',eData)
00768             (eid,pid,n1,n2) = out
00769             elem = CROD(None,out)
00770             self.addOp2Element(elem)
00771             n+=16
00772         ###
00773         data = data[n:]
00774 
00775 # CRROD
00776 # CSEAM
00777 
00778     def readCSHEAR(self,data):
00779         """
00780         CSHEAR(3101,31,61)    - the marker for Record 83
00781         """
00782         #print "reading CSHEAR"
00783         n = 0
00784         nEntries = len(data)//24 # 6*4
00785         for i in xrange(nEntries):
00786             eData = data[n:n+24]
00787             out = unpack(b'iiiiii',eData)
00788             (eid,pid,n1,n2,n3,n4) = out
00789             elem = CSHEAR(None,out)
00790             self.addOp2Element(elem)
00791             n+=24
00792         ###
00793         data = data[n:]
00794 
00795 # CSLOT3
00796 # CSLOT4
00797 
00798     def readCTETP(self,data):
00799         """
00800         CTETP(12201,122,9013)    - the marker for Record 86
00801         @todo create object
00802         """
00803         #print "reading CTETP"
00804         raise NotImplementedError('needs work...')
00805         while len(data)>=108: # 27*4
00806             eData = data[:108]
00807             data  = data[108:]
00808             out = unpack(b'iiiiiiiiiiiiiiiiiiiiiiiiiii',eData)
00809             (eid,pid,n1,n2,n3,n4,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,
00810             f1,f2,f3,f4,b1,ee1,ee2,ee3,ee4) = out
00811             #print "out = ",out
00812             e = [e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12]
00813             f = [f1,f2,f3,f4]
00814             ee = [ee1,ee2,ee3,ee4]
00815             
00816             #print "e  = ",e
00817             #print "f  = ",f
00818             #print "b1  = ",b1
00819             #print "ee = ",ee
00820             dataIn = [eid,pid,n1,n2,n2,n3,n4]
00821             elem = CTETRA4(None,dataIn)
00822             self.addOp2Element(elem)
00823         ###
00824 
00825     def readCTETRA(self,data):
00826         """
00827         CTETRA(5508,55,217)    - the marker for Record 87
00828         """
00829         #print "reading CTETRA"
00830         n = 0
00831         nEntries = len(data)//48 # 12*4
00832         for i in xrange(nEntries):
00833             eData = data[n:n+48]
00834             out = unpack(b'iiiiiiiiiiii',eData)
00835             (eid,pid,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10) = out
00836             #print "out = ",out
00837 
00838             dataIn   = [eid,pid,n1,n2,n3,n4]
00839             bigNodes = [n5,n6,n7,n8,n9,n10]
00840             if sum(bigNodes)>0:
00841                 elem = CTETRA10(None,dataIn+bigNodes)
00842             else:
00843                 elem = CTETRA4(None,dataIn)
00844             self.addOp2Element(elem)
00845             n+=48
00846         ###
00847         data = data[n:]
00848 
00849 # CTETPR
00850 # CTETR10F
00851 # CTETR4FD
00852 # CTQUAD
00853 # CTTRIA
00854 
00855     def readCTRIA3(self,data):
00856         """
00857         CTRIA3(5959,59,282)    - the marker for Record 93
00858         """
00859         #print "reading CTRIA3"
00860         while len(data)>=52: # 13*4
00861             eData = data[:52]
00862             data  = data[52:]
00863             out = unpack(b'iiiiiffiiifff',eData)
00864             #print "eid=%s pid=%s n1=%s n2=%s n3=%s theta=%s zoffs=%s blank1=%s blank2=%s tflag=%s t1=%s t2=%s t3=%s" %(eid,pid,n1,n2,n3,theta,zoffs,blank1,blank2,tflag,t1,t2,t3)
00865             (eid,pid,n1,n2,n3,theta,zoffs,blank1,blank2,tflag,t1,t2,t3) = out
00866             dataIn = [eid,pid,n1,n2,n3,theta,zoffs,tflag,t1,t2,t3]
00867             elem = CTRIA3(None,dataIn)
00868             self.addOp2Element(elem)
00869         ###
00870 
00871 # CTRIAFD
00872 
00873     def readCTRIA6(self,data):
00874         """
00875         CTRIA6(4801,48,327)    - the marker for Record 95
00876         @warning inconsistent with dmap manual
00877         """
00878         #print "reading CTRIA6"
00879         return
00880         n = 0
00881         nEntries = len(data)//52 # 13*4
00882         for i in xrange(nEntries):
00883             eData = data[n:n+52]
00884             out = unpack(b'iiiiiiiiffffi',eData)
00885             #print "eid=%s pid=%s n1=%s n2=%s n3=%s theta=%s zoffs=%s blank1=%s blank2=%s tflag=%s t1=%s t2=%s t3=%s" %(eid,pid,n1,n2,n3,theta,zoffs,blank1,blank2,tflag,t1,t2,t3)
00886             (eid,pid,n1,n2,n3,n4,n5,n6,theta,t1,t2,t3,tflag) = out
00887             elem = CTRIA6(None,out)
00888             self.addOp2Element(elem)
00889             n+=52
00890         ###
00891         data = data[n:]
00892 
00893 # CTRIA6FD
00894 # CTRIAP
00895 
00896     def readCTRIAR(self,data): # 98
00897         self.skippedCardsFile.write('skipping CTRIAR in GEOM2\n')
00898 
00899 # CTRIAX
00900 
00901     def readCTRIAX6(self,data): # 100
00902         self.skippedCardsFile.write('skipping CTRIAX6 in GEOM2\n')
00903 
00904 # CTRIX3FD
00905 # CTRIX6FD
00906 
00907     def readCTUBE(self,data):
00908         """
00909         CTUBE(3701,37,49)    - the marker for Record 103
00910         """
00911         #print "reading CTUBE"
00912         n = 0
00913         nEntries = len(data)//16
00914         for i in xrange(nEntries):
00915             eData = data[n:n+16] # 4*4
00916             out = unpack(b'iiii',eData)
00917             (eid,pid,n1,n2) = out
00918             elem = CTUBE(None,out)
00919             self.addOp2Element(elem)
00920             n+=16
00921         ###
00922         data = data[n:]
00923 
00924     def readCVISC(self,data):
00925         """CVISC(3901,39, 50) - the marker for Record 104"""
00926         #print "reading CVISC"
00927         n = 0
00928         nEntries = len(data)//16
00929         for i in xrange(nEntries):
00930             eData = data[n:n+16] # 4*4
00931             out = unpack(b'iiii',eData)
00932             #(eid,pid,n1,n2) = out
00933             elem = CVISC(None,out)
00934             self.addOp2Element(elem)
00935             n+=16
00936         ###
00937         data = data[n:]
00938 
00939     def readCWELD(self,data): # 105
00940         self.skippedCardsFile.write('skipping CWELD in GEOM2\n')
00941 
00942     def readCWELDC(self,data): # 106
00943         self.skippedCardsFile.write('skipping CWELDC in GEOM2\n')
00944 
00945     def readCWELDG(self,data): # 107
00946         self.skippedCardsFile.write('skipping CWELDG in GEOM2\n')
00947 
00948 # CWSEAM
00949 # GENEL
00950 # GMDNDC
00951 # GMBNDS
00952 # GMINTC
00953 # GMINTS
00954 # PLOTEL
00955 # RADBC
00956 # RADINT
00957 # SINT
00958 
00959     def readSPOINT(self,data):
00960         """
00961         (5551,49,105)    - the marker for Record 118
00962         """
00963         while len(data)>=4: # 4*4
00964             eData = data[:4]
00965             data  = data[4:]
00966             (nid) = unpack(b'i',eData)
00967             spoint = SPOINTs(None,[nid])
00968             self.addSPoint(spoint)
00969         ###
00970 
00971 # VUBEAM
00972 # VUHEXA
00973 # VUQUAD4
00974 # VUPENTA
00975 # VUTETRA
00976 # VUTRIA
00977 # VUBEAM
00978 # VUHEXA
00979 # VUQUAD4
00980 # WELDP
 All Classes Namespaces Files Functions Variables