pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
mpt.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 
00026 from __future__ import division, print_function
00027 import sys
00028 from struct import unpack
00029 
00030 from pyNastran.bdf.cards.materials import (CREEP, MAT1, MAT2, MAT3, MAT4, MAT5,
00031                                            MAT8, MAT9, MAT10, MATS1, MATHP)
00032 from pyNastran.bdf.cards.dynamic import NLPARM, TSTEP, TSTEPNL
00033 
00034 class MPT(object):
00035 
00036     def readTable_MPTS(self):
00037         self.tableName = 'MPT'
00038         self.bigMaterials = {}
00039         self.iTableMap = {
00040                          (1003,10,245): self.readCREEP, # record 1
00041                          (103,1,77):    self.readMAT1,  # record 2
00042                          (203,2,78):    self.readMAT2,  # record 3
00043                          (1403,14,122): self.readMAT3,  # record 4
00044                          (2103,21,234): self.readMAT4,  # record 5
00045                          (2203,22,235): self.readMAT5,  # record 6
00046                          (2503,25,288): self.readMAT8,  # record 7
00047                          (2603,26,300): self.readMAT9,  # record 8 - buggy
00048                          (2801,28,365): self.readMAT10, # record 9
00049                          (4506,45,374): self.readMATHP, # record 11
00050                          (503,  5, 90): self.readMATS1, # record 12
00051 
00052                          (3003,30,286): self.readNLPARM,  # record 27
00053                          (3104,32,350): self.readNLPCI,   # record 28
00054                          (3103,31,337): self.readTSTEPNL, # record 29
00055                          (703,  7, 91): self.readMATT1,   # record 13 - not done
00056                          (803,  8,102): self.readMATT2,   # record 14 - not done
00057                          (1503,14,189): self.readMATT3,   # record 15 - not done
00058                          (2303,23,237): self.readMATT4,   # record 16 - not done
00059                          (2403,24,238): self.readMATT5,   # record 17 - not done
00060                          (2703,27,301): self.readMATT9,   # record 19 - not done
00061                         #(8802,88,413): self.readRADM,    # record 25 - not done
00062 
00063                          }
00064 
00065         self.readRecordTable('MPTS')
00066 
00067     def addOp2Material(self,mat):
00068         self.addMaterial(mat,allowOverwrites=True)
00069 
00070     def readCREEP(self,data):
00071         """
00072         CREEP(1003,10,245) - record 1
00073         """
00074         #print "reading CREEP"
00075         while len(data)>=64: # 16*4
00076             eData = data[:64]
00077             data  = data[64:]
00078             out = unpack(b'iffiiiififffffff',eData)
00079             (mid,T0,exp,form,tidkp,tidcp,tidcs,thresh,Type,ag1,ag2,ag3,ag4,ag5,ag6,ag7) = out
00080             mat = CREEP(None,out)
00081             self.addCreepMaterial(mat,allowOverwrites=True)
00082         ###
00083 
00084     def readMAT1(self,data):
00085         """
00086         MAT1(103,1,77) - record 2
00087         """
00088         #print "reading MAT1"
00089         while len(data)>=48: # 12*4
00090             eData = data[:48]
00091             data  = data[48:]
00092             out = unpack(b'iffffffffffi',eData)
00093             (mid,E,G,nu,rho,A,TRef,ge,St,Sc,Ss,mcsid) = out
00094             mat = MAT1(None,out)
00095             self.addOp2Material(mat)
00096         ###
00097 
00098     def readMAT2(self,data):
00099         """
00100         MAT2(203,2,78) - record 3
00101         """
00102         #print "reading MAT2"
00103         while len(data)>=68: # 17*4
00104             eData = data[:68]
00105             data  = data[68:]
00106             out = unpack(b'ifffffffffffffffi',eData)
00107             (mid,g1,g2,g3,g4,g5,g6,rho,aj1,aj2,aj3,TRef,ge,St,Sc,Ss,mcsid) = out
00108             #print "MAT2 = ",out
00109             mat = MAT2(None,out)
00110 
00111             if mid > 1e8 or mid < 0:  # just a checker for out of range materials
00112                 self.bigMaterials[mid] = mat
00113             else:
00114                 self.addOp2Material(mat)
00115             ###
00116         ###
00117 
00118     def readMAT3(self,data):
00119         """
00120         MAT3(1403,14,122) - record 4
00121         """
00122         #print "reading MAT3"
00123         while len(data)>=64: # 16*4
00124             eData = data[:64]
00125             data  = data[64:]
00126             out = unpack(b'iffffffffifffffi',eData)
00127             (mid,ex,eth,ez,nuxth,nuthz,nuzx,rho,gzx,blank,ax,ath,az,TRef,ge,blank) = out
00128             mat = MAT3(None,[mid,ex,eth,ez,nuxth,nuthz,nuzx,rho,gzx,ax,ath,az,TRef,ge])
00129             self.addOp2Material(mat)
00130         ###
00131 
00132     def readMAT4(self,data):
00133         """
00134         MAT4(2103,21,234) - record 5
00135         """
00136         #print "reading MAT4"
00137         while len(data)>=44: # 11*4
00138             eData = data[:44]
00139             data  = data[44:]
00140             out = unpack(b'iffffffffff',eData)
00141             (mid,k,cp,rho,h,mu,hgen,refenth,tch,tdelta,qlat) = out
00142             mat = MAT4(None,out)
00143             self.addThermalMaterial(mat,allowOverwrites=True)
00144         ###
00145 
00146     def readMAT5(self,data):
00147         """
00148         MAT5(2203,22,235) - record 6
00149         """
00150         #print "reading MAT5"
00151         while len(data)>=40: # 10*4
00152             eData = data[:40]
00153             data  = data[40:]
00154             out = unpack(b'ifffffffff',eData)
00155             (mid,k1,k2,k3,k4,k5,k6,cp,rho,hgen) = out
00156             mat = MAT5(None,out)
00157             self.addThermalMaterial(mat,allowOverwrites=True)
00158         ###
00159 
00160     def readMAT8(self,data):
00161         """
00162         MAT8(2503,25,288) - record 7
00163         """
00164         #print "reading MAT8"
00165         while len(data)>=76: # 19*4
00166             eData = data[:76]
00167             data  = data[76:]
00168             out = unpack(b'iffffffffffffffffff',eData)
00169             (mid,E1,E2,nu12,G12,G1z,G2z,rho,a1,a2,TRef,Xt,Xc,Yt,Yc,S,ge,f12,strn) = out
00170             mat = MAT8(None,out)
00171             self.addOp2Material(mat)
00172         ###
00173 
00174     def readMAT9(self,data):
00175         """
00176         MAT9(2603,26,300) - record 9
00177         @todo buggy
00178         """
00179         #print "reading MAT9"
00180         while len(data)>=140: # 35*4
00181             eData = data[:140]
00182             data  = data[140:]
00183             out = unpack(b'iiiiiiiiiiiiiiiiiiiiiifffffffffiiii',eData)
00184             
00185             (mid,g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,g11,g12,g13,g14,g15,g16,g17,g18,g19,g20,g21,
00186             rho,a1,a2,a3,a4,a5,a6,TRef,ge,blank1,blank2,blank3,blank4) = out
00187             dataIn = [mid,[g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,g11,g12,g13,g14,g15,g16,g17,g18,g19,g20,g21],
00188                       rho,[a1,a2,a3,a4,a5,a6],
00189                       TRef,ge]
00190             #print "dataIn = ",dataIn
00191             mat = MAT9(None,dataIn)
00192             self.addOp2Material(mat)
00193         ###
00194 
00195     def readMAT10(self,data):
00196         """
00197         MAT10(2801,28,365) - record 9
00198         """
00199         #print "reading MAT10"
00200         while len(data)>=20: # 5*4
00201             eData = data[:20]
00202             data  = data[20:]
00203             out = unpack(b'iffff',eData)
00204             (mid,bulk,rho,c,ge) = out
00205             mat = MAT10(None,out)
00206             self.addOp2Material(mat)
00207         ###
00208 
00209 # MAT11 - unused
00210 
00211     def readMATHP(self,data):
00212         """MATHP(4506,45,374) - Record 11"""
00213         #print "reading MATHP"
00214         while len(data)>=140: # 35*4
00215             eData = data[:140]
00216             data  = data[140:]
00217             out1 = unpack(b'ifffffffiiifffffffffffffffffffffffi',eData)
00218             (mid,a10,a01,d1,rho,alpha,tref,ge,sf,na,nd,kp,
00219              a20,a11,a02,d2,
00220              a30,a21,a12,a03,d3,
00221              a40,a31,a22,a13,a04,d4,
00222              a50,a41,a32,a23,a14,a05,d5,
00223              continueFlag) = out1
00224             dataIn = [out1]
00225 
00226             if continueFlag:
00227                 eData = data[:32] # 7*4
00228                 data  = data[32:]            
00229                 out2 = unpack(b'iiiiiiii',eData)
00230                 (tab1,tab2,tab3,tab4,x1,x2,x3,tab5) = out2
00231                 data.append(out2)
00232             mat = MATHP(None,dataIn)
00233             self.addOp2Material(mat)
00234         ###
00235 
00236     def readMATS1(self,data):
00237         """
00238         MATS1(503,5,90) - record 12
00239         """
00240         #print "reading MATS1"
00241         while len(data)>=44: # 11*4
00242             eData = data[:44]
00243             data  = data[44:]
00244             out = unpack(b'iiifiiffiii',eData)
00245             (mid,tid,Type,h,yf,hr,limit1,limit2,a,b,c) = out
00246             dataIn = [mid,tid,Type,h,yf,hr,limit1,limit2]
00247             mat = MATS1(None,dataIn)
00248             self.addMaterialDependence(mat,allowOverwrites=True)
00249         ###
00250 
00251     def readMATT1(self,data):
00252         self.skippedCardsFile.write('skipping MATT1 in MPT\n')
00253 
00254     def readMATT2(self,data):
00255         self.skippedCardsFile.write('skipping MATT2 in MPT\n')
00256 
00257     def readMATT3(self,data):
00258         self.skippedCardsFile.write('skipping MATT3 in MPT\n')
00259 
00260     def readMATT4(self,data):
00261         self.skippedCardsFile.write('skipping MATT4 in MPT\n')
00262 
00263     def readMATT5(self,data):
00264         self.skippedCardsFile.write('skipping MATT5 in MPT\n')
00265 
00266 # MATT8 - unused
00267 
00268     def readMATT9(self,data):
00269         self.skippedCardsFile.write('skipping MATT9 in MPT\n')
00270 
00271 # MBOLT
00272 # MBOLTUS
00273 # MSTACK
00274 # NLAUTO
00275 # RADBND
00276 
00277     def readRADM(self,data):
00278         """
00279         RADM(8802,88,413) - record 25
00280         @todo add object
00281         """
00282         #print "reading RADM"
00283         return
00284         while len(data)>=4: # 1*4
00285             eData = data[:4]
00286             data  = data[4:]
00287             number, = unpack(b'i',eData)
00288             
00289             iFormat = 'if'+str(number)+'f'
00290             eDataLen = len(strings)*4
00291             
00292             eData = data[:eDataLen]
00293             data = data[eDataLen:]
00294             iFormat = bytes(iFormat)
00295             pack = list(unpack(iFormat,eData))
00296             packs = []
00297             
00298             while data:
00299                 eData = data[:eDataLen]
00300                 data = data[eDataLen:]
00301                 pack = list(unpack(iFormat,eData))
00302                 packs.append(pack)
00303 
00304             #mat = RADM(None,packs)
00305             #self.addOp2Material(mat)
00306         ###
00307 
00308 # RADMT
00309 
00310     def readNLPARM(self,data):
00311         """
00312         NLPARM(3003,30,286) - record 27
00313         """
00314         #print "reading NLPARM"
00315         while len(data)>=76: # 19*4
00316             eData = data[:76]
00317             data  = data[76:]
00318             out = unpack(b'iifiiiiifffiiiffiff',eData)
00319             #(sid,ninc,dt,kMethod,kStep,maxIter,conv,intOut,epsU,epsP,epsW,
00320             # maxDiv,maxQn,maxLs,fStress,lsTol,maxBisect,maxR,rTolB) = out
00321             nlparm = NLPARM(None,out)
00322             self.addNLParm(nlparm)
00323         ###
00324 
00325     def readNLPCI(self,data):
00326         self.skippedCardsFile.write('skipping NLPCI in MPT\n')
00327 
00328     def readTSTEPNL(self,data):
00329         """
00330         TSTEPNL(3103,31,337) - record 29
00331         """
00332         #print "reading TSTEPNL"
00333         while len(data)>=88: # 19*4
00334             eData = data[:88]
00335             data  = data[88:]
00336             out = unpack(b'iifiiiiifffiiifiiiffff',eData)
00337             #(sid,ndt,dt,no,kMethod,kStep,maxIter,conv,epsU,epsP,epsW,
00338             # maxDiv,maxQn,maxLs,fStress,lsTol,maxBisect,adjust,mStep,rb,maxR,uTol,rTolB) = out
00339             tstepnl = TSTEPNL(None,out)
00340             self.addTSTEPNL(tstepnl)
00341         ###
00342         
 All Classes Namespaces Files Functions Variables