pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
geom3.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 import sys
00026 from struct import unpack
00027 
00028 from pyNastran.bdf.cards.loads.staticLoads import (FORCE, FORCE1, FORCE2, GRAV,
00029                                                    LOAD, PLOAD1, PLOAD2,
00030                                                    PLOAD4) # PLOAD3, 
00031 from pyNastran.bdf.cards.thermal.loads import QBDY1, QBDY2, QBDY3, TEMP, TEMPD
00032 
00033 
00034 class Geometry3(object):
00035 
00036     def readTable_Geom3(self):
00037         self.iTableMap = {
00038                          (4201,42,18):  self.readFORCE,   # record 3
00039                          (4001,40,20):  self.readFORCE1,  # record 4
00040                          (4101,41,22):  self.readFORCE2,  # record 5
00041                          (4401,44,26):  self.readGRAV,    # record 7 - buggy
00042                          (4551,61,84):  self.readLOAD,    # record 8
00043                          (3709,37,331): self.readLOADCYH, # record 9 - not done
00044                          (3609,36,188): self.readLSEQ,    # record 12 - not done
00045                          (4801,48,19):  self.readMOMENT,  # record 13 - not tested
00046                          (4601,46,21):  self.readMOMENT1, # record 14 - not tested
00047                          (4701,47,23):  self.readMOMENT2, # record 15 - not tested
00048                          (5101,51,24):  self.readPLOAD,   # record 16 - not done
00049                         #(6909,69,198): self.readPLOAD1,  # record 17 - buggy
00050                         #(6802,68,199): self.readPLOAD2,  # record 18 - buggy
00051                          (7109,81,255): self.readPLOAD3,  # record 19 - not done
00052                         #(7209,72,299): self.readPLOAD4,  # record 20 - buggy - g1/g3/g4
00053                          (7309,73,351): self.readPLOADX1, # record 22
00054                          (4509,45,239): self.readQBDY1,   # record 24
00055                          (4909,49,240): self.readQBDY2,   # record 25
00056                          (2109,21,414): self.readQBDY3,   # record 26
00057                          (5509,55,190): self.readRFORCE,  # record 30 - not done
00058                          (5401,54,25):  self.readSLOAD,   # record 31 - not done
00059                          (5701,57,27):  self.readTEMP,    # record 32
00060                          (5641,65,98):  self.readTEMPD,   # record 33
00061                          (8409,84,204): self.readTEMPRB,  # record 40 - not done
00062                          (8109,81,201): self.readTEMPP1,  # record 37 - not done
00063                          (8209,82,202): self.readTEMPP2,  # record 38 - not done
00064                          (8309,83,203): self.readTEMPP3,  # record 39 - not done
00065                         #(8409,84,204): self.readTEMPP4,  # record 40 - not done
00066 
00067                          }
00068         self.readRecordTable('GEOM3')
00069 
00070     def readTable_Geom3S(self):
00071         self.readTable_Geom3()
00072         #self.iTableMap = {
00073         #                 }
00074         #self.readRecordTable('GEOM3S')
00075 
00076 # ACCEL
00077 # ACCEL1
00078 
00079     def readFORCE(self,data):
00080         """
00081         FORCE(4201,42,18) - the marker for Record 3
00082         """
00083         #print "reading FORCE"
00084         n = 0
00085         nEntries = len(data)//28  # 7*4
00086         for i in xrange(nEntries):
00087             eData = data[n:n+28]
00088             (sid,g,cid,f,n1,n2,n3) = unpack('iiiffff',eData)
00089             load = FORCE(None,[sid,g,cid,f,n1,n2,n3])
00090             self.addLoad(load)
00091             n+=28
00092         ###
00093         data = data[n:]
00094 
00095     def readFORCE1(self,data):
00096         """
00097         FORCE1(4001,40,20) - the marker for Record 4
00098         """
00099         #print "reading FORCE1"
00100         n = 0
00101         nEntries = len(data)//20  # 5*4
00102         for i in xrange(nEntries):
00103             eData = data[n:n+20]
00104             (sid,g,f,n1,n2) = unpack('iifii',eData)
00105 
00106             load = FORCE1(None,[sid,g,f,n1,n2])
00107             self.addLoad(load)
00108             n+=20
00109         ###
00110         data = data[n:]
00111 
00112     def readFORCE2(self,data):
00113         """
00114         FORCE2(4101,41,22) - the marker for Record 5
00115         """
00116         #print "reading FORCE2"
00117         n = 0
00118         nEntries = len(data)//28  # 7*4
00119         for i in xrange(nEntries):
00120             eData = data[n:n+28]
00121             (sid,g,f,n1,n2,n3,n4) = unpack('iifiiii',eData)
00122 
00123             load = FORCE2(None,[sid,g,f,n1,n2,n3,n4])
00124             self.addLoad(load)
00125             n+=28
00126         ###
00127         data = data[n:]
00128 
00129 # GMLOAD
00130 
00131     def readGRAV(self,data):
00132         """
00133         GRAV(4401,44,26) - the marker for Record 7
00134         """
00135         #print "reading GRAV"
00136         n = 0
00137         nEntries = len(data)//28  # 7*4
00138         for i in xrange(nEntries):
00139             eData = data[n:n+28]
00140             out = unpack('iiffffi',eData)
00141             (sid,cid,a,n1,n2,n3,mb) = out
00142             grav = GRAV(None,out)
00143             self.addLoad(grav)
00144             n+=28
00145         ###
00146         data = data[n:]
00147 
00148     def readLOAD(self,data):
00149         """
00150         (4551, 61, 84) - the marker for Record 8
00151         @todo add object
00152         """
00153         #print "reading LOAD"
00154         while len(data)>=16: # 4*4
00155             eData = data[:16]
00156             data  = data[16:]
00157             (sid,s,si,l1) = unpack('iffi',eData)
00158             Si=[si]; L1=[l1]
00159             #print Si,L1
00160             while 1:
00161                 eData = data[:8]
00162                 data  = data[8:]
00163                 #print "len(eData) = ",len(eData)
00164                 (si,l1) = unpack('fi',eData)
00165                 siTest, = unpack('i',eData[0:4])
00166                 #print si,siTest,l1
00167                 #print type(si)
00168                 
00169                 if [siTest,l1] == [-1,-1]:
00170                     break
00171                 Si.append(si); L1.append(l1)
00172                 #print Si,L1
00173             
00174             dataIn = [sid,s,Si,L1]
00175             load = LOAD(None,dataIn)
00176             self.addLoad(load)
00177         ###
00178 
00179     def readLOADCYH(self,data):
00180         self.skippedCardsFile.write('skipping LOADCYG in GEOM3\n')
00181 
00182 # LOADCYN
00183 # LOADCYT
00184 
00185     def readLSEQ(self,data):
00186         self.skippedCardsFile.write('skipping LSEQ in GEOM3\n')
00187 
00188     def readMOMENT(self,data):
00189         """
00190         MOMENT(4801,48,19) - the marker for Record 13
00191         """
00192         #print "reading MOMENT"
00193         n = 0
00194         nEntries = len(data)//28  # 7*4
00195         for i in xrange(nEntries):
00196             eData = data[n:n+28]
00197             out = unpack('iiiffff',eData)
00198             (sid,g,cid,m,n1,n2,n3) = out
00199 
00200             load = FORCE1(None,out)
00201             self.addLoad(load)
00202             n+=28
00203         ###
00204         data = data[n:]
00205 
00206     def readMOMENT1(self,data):
00207         """
00208         MOMENT1(4601,46,21) - the marker for Record 14
00209         """
00210         #print "reading MOMENT1"
00211         n = 0
00212         nEntries = len(data)//20  # 5*4
00213         for i in xrange(nEntries):
00214             eData = data[n:n+20]
00215             out = unpack('iifii',eData)
00216             (sid,g,m,n1,n2) = out
00217             load = FORCE1(None,out)
00218             self.addLoad(load)
00219             n+=20
00220         ###
00221         data = data[n:]
00222 
00223     def readMOMENT2(self,data):
00224         """
00225         MOMENT2(4701,47,23) - the marker for Record 15
00226         """
00227         #print "reading MOMENT2"
00228         n = 0
00229         nEntries = len(data)//28  # 7*4
00230         for i in xrange(nEntries):
00231             eData = data[n:n+28]
00232             out = unpack('iifiiii',eData)
00233             (sid,g,m,n1,n2,n3,n4) = out
00234 
00235             load = FORCE1(None,out)
00236             self.addLoad(load)
00237             n+=28
00238         ###
00239         data = data[n:]
00240 
00241     def readPLOAD(self,data):
00242         pass
00243 
00244     def readPLOAD1(self,data):
00245         """
00246         PLOAD2(6802,68,199) - the marker for Record 17
00247         """
00248         #print "reading PLOAD1"
00249         n = 0
00250         nEntries = len(data)//32  # 8*4
00251         for i in xrange(nEntries):
00252             eData = data[n:n+32]
00253             out = unpack('iiiiffff',eData)
00254             (sid,eid,Type,scale,x1,p1,x2,p2) = out
00255             #print "PLOAD1 = ",out
00256             load = PLOAD1(None,out)
00257             self.addLoad(load)
00258             n+=32
00259         ###
00260         data = data[n:]
00261 
00262     def readPLOAD2(self,data):
00263         """
00264         PLOAD2(6802,68,199) - the marker for Record 18
00265         """
00266         #print "reading PLOAD2"
00267         n = 0
00268         nEntries = len(data)//12  # 3*4
00269         for i in xrange(nEntries):
00270             eData = data[n:n+12]
00271             out = unpack('ifi',eData)
00272             (sid,p,eid) = out
00273             load = PLOAD2(None,out)
00274             self.addLoad(load)
00275             n+=12
00276         ###
00277         data = data[n:]
00278 
00279     def readPLOAD3(self,data):
00280         """
00281         PLOAD3(7109,71,255) - the marker for Record 19
00282         """
00283         #print "reading PLOAD3"
00284         n = 0
00285         nEntries = len(data)//20  # 5*4
00286         for i in xrange(nEntries):
00287             eData = data[n:n+20]
00288             out = unpack('if3i',eData)
00289             (sid,p,eid,n1,n2) = out
00290             load = PLOAD3(None,out)
00291             self.addLoad(load)
00292             n+=20
00293         ###
00294         data = data[n:]
00295 
00296     def readPLOAD4(self,data): ## inconsistent with DMAP
00297         """
00298         PLOAD4(7209,72,299) - the marker for Record 20
00299         """
00300         #print "reading PLOAD4"
00301         n = 0
00302         nEntries = len(data)//48  # 13*4
00303         for i in range(nEntries):
00304             eData = data[n:n+48]
00305                          #iiffffiiifffi   ssssssssssssssss
00306             out = unpack('2i4f3i3f',eData)
00307             (sid,eid,p1,p2,p3,p4,g1,g34,cid,n1,n2,n3) = out
00308             #s1,s2,s3,s4,s5,s6,s7,s8,L1,L2,L3,L4,L5,L6,L7,L8
00309             #sdrlA = s1+s2+s3+s4
00310             #sdrlB = s5+s6+s7+s8
00311             #ldirA = L1+L2+L3+L4
00312             #ldirB = L5+L6+L7+L8
00313             sdrlA = None
00314             sdrlB = None
00315             ldirA = None
00316             ldirB = None
00317             load = PLOAD4(None,[sid,eid,[p1,p2,p3,p4],g1,g34,cid,[n1,n2,n3],sdrlA,sdrlB,ldirA,ldirB])
00318             self.addLoad(load)
00319             n+=48
00320         ###
00321         data = data[n:]
00322 
00323 
00324 # PLOADX - obsolete
00325 
00326     def readPLOADX1(self,data):
00327         self.skippedCardsFile.write('skipping PLOADX1 in GEOM3\n')
00328 
00329 # PRESAX
00330 
00331     def readQBDY1(self,data):
00332         """
00333         QBDY1(4509,45,239) - the marker for Record 24
00334         """
00335         #print "reading QBDY1"
00336         n = 0
00337         nEntries = len(data)//12  # 3*4
00338         for i in range(nEntries):
00339             eData = data[n:n+12]
00340             out = unpack('ifi',eData)
00341             (sid,q0,eid) = out
00342             load = QBDY1(None,out)
00343             self.addThermalLoad(load)
00344             n+=12
00345         ###
00346         data = data[n:]
00347 
00348     def readQBDY2(self,data):
00349         """
00350         QBDY2(4909,49,240) - the marker for Record 25
00351         """
00352         #print "reading QBDY2"
00353         n = 0
00354         nEntries = len(data)//40  # 10*4
00355         for i in range(nEntries):
00356             eData = data[n:n+40]
00357             out = unpack('iiffffffff',eData)
00358             (sid,eid,q1,q2,q3,q4,q5,q6,q7,q8) = out
00359             load = QBDY2(None,out)
00360             self.addThermalLoad(load)
00361             n+=40
00362         ###
00363         data = data[n:]
00364 
00365     def readQBDY3(self,data):
00366         """
00367         QBDY3(2109,21,414) - the marker for Record 26
00368         """
00369         #print "reading QBDY3"
00370         n = 0
00371         nEntries = len(data)//16  # 4*4
00372         for i in range(nEntries):
00373             eData = data[n:n+16]
00374             out = unpack('ifii',eData)
00375             (sid,q0,cntrlnd,eid) = out
00376             load = QBDY3(None,out)
00377             self.addThermalLoad(load)
00378             n+=16
00379         ###
00380         data = data[n:]
00381 
00382     def readTEMP(self,data):
00383         """
00384         TEMP(5701,57,27) - the marker for Record 32
00385         @warning buggy
00386         """
00387         #print "reading TEMP"
00388         n = 0
00389         nEntries = len(data)//12  # 3*4
00390         for i in range(nEntries):
00391             eData = data[n:n+12]
00392             out = unpack('iif',eData)
00393             (sid,g,T) = out
00394             if g<10000000:
00395                 load = TEMP(None,out)
00396                 self.addThermalLoad(load)
00397             else:
00398                 self.log.debug('TEMP = %s' %(out))
00399             n+=12
00400         ###
00401         data = data[n:]
00402 
00403     def readTEMPD(self,data):
00404         """
00405         TEMPD(5641,65,98) - the marker for Record 33
00406         @todo add object
00407         """
00408         #print "reading TEMPD"
00409         n = 0
00410         nEntries = len(data)//8  # 2*4
00411         for i in range(nEntries):
00412             eData = data[n:n+8]
00413             out = unpack('if',eData)
00414             (sid,T) = out
00415             load = TEMPD(None,out)
00416             #self.addThermalLoad(load)
00417             n+=8
00418         ###
00419         data = data[n:]
00420 
00421 # QHBDY
00422 # QVECT
00423 # QVOL
00424 
00425     def readRFORCE(self,data):
00426         self.skippedCardsFile.write('skipping RFORCE in GEOM3\n')
00427 
00428     def readSLOAD(self,data):
00429         self.skippedCardsFile.write('skipping SLOAD in GEOM3\n')
00430  
00431 # TEMP(5701,57,27) # 32
00432 # TEMPD(5641,65,98) # 33
00433 # TEMPEST
00434 # TEMPF
00435 # TEMP1C
00436 
00437     def readTEMPP1(self,data):
00438         self.skippedCardsFile.write('skipping TEMPP1 in GEOM3\n')
00439 
00440     def readTEMPP2(self,data):
00441         self.skippedCardsFile.write('skipping TEMPP2 in GEOM3\n')
00442 
00443     def readTEMPP3(self,data):
00444         self.skippedCardsFile.write('skipping TEMPP3 in GEOM3\n')
00445 
00446     def readTEMPRB(self,data):
00447         self.skippedCardsFile.write('skipping TEMPRB in GEOM3\n')
00448 
00449 # PFACE
00450 # PEDGE
00451 
 All Classes Namespaces Files Functions Variables