pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
thermal_elements.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 .oef_thermalObjects import (HeatFlux_CHBDYx, HeatFlux_2D_3D, HeatFlux_1D,
00031                                  HeatFlux_VU, HeatFlux_VUBEAM, HeatFlux_VU_3D,
00032                                  HeatFlux_CONV)
00033 
00034 
00035 class ThermalElements(object):
00036 
00037     def readOEF_Thermal(self):
00038         assert self.formatCode==1,self.codeInformation()
00039         #print "self.elementType = ",self.elementType
00040         if self.elementType in [107,108,109]: # CHBDYE, CHBDYG, CHBDYP
00041             assert self.numWide==8,self.codeInformation()
00042             self.createTransientObject(self.thermalLoad_CHBDY,HeatFlux_CHBDYx)
00043             self.handleResultsBuffer3(self.OEF_CHBDYx,resultName='thermalLoad_CHBDY')
00044         elif self.elementType in [33,39,67,68]: # QUAD4,TETRA,HEXA,PENTA
00045             assert self.numWide in [9,10],self.codeInformation()
00046             self.createTransientObject(self.thermalLoad_2D_3D,HeatFlux_2D_3D)
00047             self.handleResultsBuffer3(self.OEF_2D_3D,resultName='thermalLoad_2D_3D')
00048         elif self.elementType in [53,64,74,75]: # TRIAX6,QUAD8,TRIA3,TRIA6
00049             assert self.numWide==9,self.codeInformation()
00050             self.createTransientObject(self.thermalLoad_2D_3D,HeatFlux_2D_3D)
00051             self.handleResultsBuffer3(self.OEF_2D_3D,resultName='thermalLoad_2D_3D')
00052         elif self.elementType in [1,2,3,10,34,69]: # ROD,BEAM,TUBE,CONROD,BAR,BEND
00053             assert self.numWide==9,self.codeInformation()
00054             self.createTransientObject(self.thermalLoad_1D,HeatFlux_1D)
00055             self.handleResultsBuffer3(self.OEF_1D,resultName='thermalLoad_1D')
00056         elif self.elementType in [189,190]: # VUQUAD,VUTRIA
00057             #assert self.numWide==27,self.codeInformation()
00058             self.createTransientObject(self.thermalLoad_VU,HeatFlux_VU)
00059             self.handleResultsBuffer3(self.OEF_VU_Element,resultName='thermalLoad_VU')
00060         elif self.elementType in [191]: # VUBEAM
00061             #assert self.numWide==27,self.codeInformation()
00062             self.createTransientObject(self.thermalLoad_VUBeam,HeatFlux_VUBEAM)
00063             self.handleResultsBuffer3(self.OEF_VUBeam_Element,resultName='thermalLoad_VUBeam')
00064         elif self.elementType in [145,146,147]: # VUHEXA,VUPENTA,VUTETRA
00065             self.createTransientObject(self.thermalLoad_VU_3D,HeatFlux_VU_3D)
00066             self.handleResultsBuffer3(self.OEF_VU_3D_Element,resultName='thermalLoad_VU_3D')
00067         elif self.elementType in [110]:
00068             self.createTransientObject(self.thermalLoad_CONV,HeatFlux_CONV)
00069             self.handleResultsBuffer3(self.OEF_CONV,resultName='thermalLoad_CONV')
00070         else:
00071             self.NotImplementedOrSkip()
00072         ###
00073 
00074     def OEF_CHBDYx(self): # [107,108,109]  CHBDYE, CHBDYG, CHBDYP
00075         if self.makeOp2Debug:
00076             self.op2Debug.write('---OEF_CHBDYx---\n')
00077         #deviceCode = self.deviceCode
00078         
00079         dt = self.nonlinearFactor
00080         isSort1 = self.isSort1()
00081         if isSort1:
00082             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00083             format1 = 'i8s5f' # SORT1
00084             extract = self.extractSort1
00085             #dt = self.nonlinearFactor
00086         else:
00087             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00088             format1 = 'f8s5f' # SORT2
00089             extract = self.extractSort2
00090             #eid = self.nonlinearFactor
00091         format1 = bytes(format1)
00092 
00093         while len(self.data)>=32: # 8*4
00094             eData     = self.data[0:32]
00095             self.data = self.data[32: ]
00096             #print "len(data) = ",len(eData)
00097 
00098             out = unpack(format1, eData)
00099             (eid,eType,fApplied,freeConv,forceConv,fRad,fTotal) = out
00100             eid2  = extract(eid,dt)
00101             #print "eType=%s" %(eType)
00102             
00103             dataIn = [eid2,eType,fApplied,freeConv,forceConv,fRad,fTotal]
00104             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00105             #eid = self.obj.addNewEid(out)
00106             self.obj.add(dt,dataIn)
00107             #print "len(data) = ",len(self.data)
00108         ###
00109         if self.makeOp2Debug:
00110             print("done with OEF_CHBDYx")
00111         #print(self.thermalLoad_CHBDY)
00112 
00113     def OEF_CONV(self): # [110]  CONV
00114         if self.makeOp2Debug:
00115             self.op2Debug.write('---OEF_CONV---\n')
00116         #deviceCode = self.deviceCode
00117         
00118         dt = self.nonlinearFactor
00119         isSort1 = self.isSort1()
00120         if isSort1:
00121             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00122             format1 = 'ifif' # SORT1
00123             extract = self.extractSort1
00124             #dt = self.nonlinearFactor
00125         else:
00126             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00127             format1 = 'ffif' # SORT2
00128             extract = self.extractSort2
00129             #eid = self.nonlinearFactor
00130         format1 = bytes(format1)
00131 
00132         while len(self.data)>=16: # 4*4
00133             eData     = self.data[0:16]
00134             self.data = self.data[16: ]
00135             #print "len(data) = ",len(eData)
00136 
00137             out = unpack(format1, eData)
00138             (eid,cntlNode,freeConv,freeConvK) = out
00139             eid2  = extract(eid,dt)
00140             
00141             dataIn = [eid2,cntlNode,freeConv,freeConvK]
00142             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00143             self.obj.add(dt,dataIn)
00144             #print "len(data) = ",len(self.data)
00145         ###
00146         if self.makeOp2Debug:
00147             print("done with OEF_CONV")
00148         #print(self.thermalLoad_CHBDY)
00149 
00150     def OEF_VU_Element(self): # 189-VUQUAD 190-VUTRIA,191-VUBEAM
00151         dt = self.nonlinearFactor
00152         isSort1 = self.isSort1()
00153         #print "numWide = ",self.numWide
00154 
00155         if self.elementType in [189]:
00156             nNodes = 4
00157         elif self.elementType in [190]:
00158             nNodes = 3
00159         elif self.elementType in [191]:
00160             nNodes = 2
00161         else:
00162             raise NotImplementedError(self.codeInformation())
00163 
00164         if isSort1:
00165             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00166             format1 = 'iii4sii' # SORT1
00167             extract = self.extractSort1
00168             #dt = self.nonlinearFactor
00169         else:
00170             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00171             format1 = 'fii4sii' # SORT2
00172             extract = self.extractSort2
00173             #eid = self.nonlinearFactor
00174         ###
00175         formatAll = 'iffffff'
00176         format1 = bytes(format1)
00177         formatAll = bytes(formatAll)
00178 
00179         n = 24+28*nNodes
00180         while len(self.data)>=n:
00181             eData     = self.data[0:24] # 6*4
00182             self.data = self.data[24: ]
00183             #print "len(data) = ",len(eData)
00184 
00185             out = unpack(format1, eData)
00186             (eid,parent,coord,icord,theta,null) = out
00187 
00188             eid2  = extract(eid,dt)
00189             dataIn = [eid2,parent,coord,icord,theta]
00190 
00191             gradFluxes = []
00192             for i in xrange(nNodes):
00193                 eData     = self.data[0:28] # 7*4
00194                 self.data = self.data[28: ]
00195                 #print "i=%s len(data)=%s" %(i,len(eData))
00196                 out = unpack(formatAll, eData)
00197                 gradFluxes.append(out)
00198             dataIn.append(gradFluxes)
00199             #eType = a+b+c+d+e+f+g+h
00200             #print "eType=%s" %(eType)
00201             
00202             #dataIn = [eid2,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux]
00203             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00204             #eid = self.obj.addNewEid(out)            
00205             self.obj.add(nNodes,dt,dataIn)
00206             #print "len(data) = ",len(self.data)
00207         ###
00208         if self.makeOp2Debug:
00209             print("done with OEF_1D")
00210         #print self.thermalLoad_VU
00211 
00212     def OEF_VUBeam_Element(self): # 191-VUBEAM
00213         dt = self.nonlinearFactor
00214         isSort1 = self.isSort1()
00215         #print "numWide = ",self.numWide
00216 
00217         if self.elementType in [191]:
00218             nNodes = 2
00219         else:
00220             raise NotImplementedError(self.codeInformation())
00221 
00222         if isSort1:
00223             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00224             format1 = 'iii4s' # SORT1
00225             extract = self.extractSort1
00226             #dt = self.nonlinearFactor
00227         else:
00228             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00229             format1 = 'fii4s' # SORT2
00230             extract = self.extractSort2
00231             #eid = self.nonlinearFactor
00232         ###
00233         formatAll = 'i6f'
00234         format1 = bytes(format1)
00235         formatAll = bytes(formatAll)
00236 
00237         n = 16+28*nNodes
00238         while len(self.data)>=n:
00239             eData     = self.data[0:16] # 4*4
00240             self.data = self.data[16: ]
00241             #print "len(data) = ",len(eData)
00242 
00243             out = unpack(format1, eData)
00244             (eid,parent,coord,icord) = out
00245 
00246             eid2  = extract(eid,dt)
00247             dataIn = [eid2,parent,coord,icord]
00248 
00249             gradFluxes = []
00250             for i in xrange(nNodes):
00251                 eData     = self.data[0:28] # 7*4
00252                 self.data = self.data[28: ]
00253                 #print "i=%s len(data)=%s" %(i,len(eData))
00254                 out = unpack(formatAll, eData)
00255                 gradFluxes.append(out)
00256             dataIn.append(gradFluxes)
00257             #eType = a+b+c+d+e+f+g+h
00258             #print "eType=%s" %(eType)
00259             
00260             #dataIn = [eid2,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux]
00261             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00262             #eid = self.obj.addNewEid(out)            
00263             self.obj.add(nNodes,dt,dataIn)
00264             #print "len(data) = ",len(self.data)
00265         ###
00266         if self.makeOp2Debug:
00267             print("done with OEF_1D")
00268         #sys.exit('thermalLoad_VUBeam')
00269         #print self.thermalLoad_VUBeam
00270 
00271     def OEF_VU_3D_Element(self): # 146-VUPENTA, 147-VUTETRA, 148-VUPENTA
00272         dt = self.nonlinearFactor
00273         isSort1 = self.isSort1()
00274         #print "numWide = ",self.numWide
00275 
00276         if self.elementType in [147]:
00277             nNodes = 4
00278         elif self.elementType in [146]:
00279             nNodes = 6
00280         elif self.elementType in [145]:
00281             nNodes = 8
00282         else:
00283             raise NotImplementedError(self.codeInformation())
00284 
00285         if isSort1:
00286             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00287             format1 = 'ii' # SORT1
00288             extract = self.extractSort1
00289             #dt = self.nonlinearFactor
00290         else:
00291             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00292             format1 = 'fi' # SORT2
00293             extract = self.extractSort2
00294             #eid = self.nonlinearFactor
00295         ###
00296         formatAll = 'i6f'
00297         format1 = bytes(format1)
00298         formatAll = bytes(formatAll)
00299 
00300         n = 8+28*nNodes
00301         while len(self.data)>=n:
00302             eData     = self.data[0:8] # 2*4
00303             self.data = self.data[8: ]
00304             #print "len(data) = ",len(eData)
00305 
00306             out = unpack(format1, eData)
00307             (eid,parent) = out
00308 
00309             eid2  = extract(eid,dt)
00310             dataIn = [eid2,parent]
00311 
00312             gradFluxes = []
00313             for i in xrange(nNodes):
00314                 eData     = self.data[0:7*4]
00315                 self.data = self.data[7*4: ]
00316                 #print "i=%s len(data)=%s" %(i,len(eData))
00317                 out = unpack(formatAll, eData)
00318                 gradFluxes.append(out)
00319             dataIn.append(gradFluxes)
00320             
00321             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00322             self.obj.add(nNodes,dt,dataIn)
00323             #print "len(data) = ",len(self.data)
00324         ###
00325         if self.makeOp2Debug:
00326             print("done with OEF_VU_3D_Element")
00327         #print self.thermalLoad_VU_3D
00328 
00329     def OEF_1D(self): # 1-ROD, 2-BEAM, 3-TUBE, 10-CONROD, 34-BAR, 69-BEND
00330         dt = self.nonlinearFactor
00331         isSort1 = self.isSort1()
00332         #print "numWide = ",self.numWide
00333         n = 36
00334         if isSort1:
00335             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00336             format1 = 'i8sffffff' # SORT1
00337             extract = self.extractSort1
00338             #dt = self.nonlinearFactor
00339         else:
00340             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00341             format1 = 'f8sffffff' # SORT2
00342             extract = self.extractSort2
00343             #eid = self.nonlinearFactor
00344         ###
00345         format1 = bytes(format1)
00346 
00347         n = 36
00348         while len(self.data)>=n: # 10*4
00349             eData     = self.data[0:n]
00350             self.data = self.data[n: ]
00351             #print "len(data) = ",len(eData)
00352 
00353             out = unpack(format1, eData)
00354             (eid,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux) = out
00355             eid2  = extract(eid,dt)
00356             #print "eType=%s" %(eType)
00357             
00358             dataIn = [eid2,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux]
00359             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00360             #eid = self.obj.addNewEid(out)            
00361             self.obj.add(dt,dataIn)
00362             #print "len(data) = ",len(self.data)
00363         ###
00364         if self.makeOp2Debug:
00365             print("done with OEF_1D")
00366         #print self.thermalLoad_1D
00367 
00368     def OEF_2D_3D(self): # 33-QUAD4, 39-TETRA, 53-TRIAX6,64-QUAD8, 67-HEXA, 68-PENTA, 74-TRIA3, 75-TRIA6
00369         """numWide==10"""
00370         dt = self.nonlinearFactor
00371         isSort1 = self.isSort1()
00372         #print "numWide = ",self.numWide
00373         #print "dt = ",dt
00374         if self.elementType in [39,67,68]: # HEXA,PENTA
00375             n = 40
00376             if isSort1:
00377                 #print "SORT1 - %s" %(self.ElementType(self.elementType))
00378                 format1 = 'i8s6fi' # SORT1
00379                 extract = self.extractSort1
00380                 #dt = self.nonlinearFactor
00381             else:
00382                 #print "SORT2 - %s" %(self.ElementType(self.elementType))
00383                 format1 = 'f8s6fi' # SORT2
00384                 extract = self.extractSort2
00385                 #eid = self.nonlinearFactor
00386         elif self.elementType in [33,53,64,74,75]: # no zed on this element for some reason...
00387             n = 36
00388             if isSort1:
00389                 #print "SORT1 - %s" %(self.ElementType(self.elementType))
00390                 format1 = 'i8s6f' # SORT1
00391                 extract = self.extractSort1
00392                 #dt = self.nonlinearFactor
00393             else:
00394                 #print "SORT2 - %s" %(self.ElementType(self.elementType))
00395                 format1 = 'f8s6f' # SORT2
00396                 extract = self.extractSort2
00397                 #eid = self.nonlinearFactor
00398             ###
00399         else:
00400             raise NotImplementedError(self.codeInformation())
00401         ###
00402         format1 = bytes(format1)
00403 
00404 
00405         while len(self.data)>=n: # 10*4
00406             eData     = self.data[0:n]
00407             self.data = self.data[n: ]
00408 
00409             out = unpack(format1, eData)
00410             #print("len(out)=",len(out))
00411             # len=8
00412             (eid,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux) = out[:8]
00413             eid2  = extract(eid,dt)
00414             #print "eType=%s" %(eType)
00415             
00416             dataIn = [eid2,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux]
00417             #print "heatFlux %s" %(self.ElementType(self.elementType)),dataIn
00418             #eid = self.obj.addNewEid(out)
00419             self.obj.add(dt,dataIn)
00420             #print "len(data) = ",len(self.data)
00421         ###
00422         if self.makeOp2Debug:
00423             print("done with OEF_2D_3D")
00424         
00425         #print self.thermalLoad_2D_3D
00426 
 All Classes Namespaces Files Functions Variables