pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
oef_thermalObjects.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 
00028 from pyNastran.op2.resultObjects.op2_Objects import scalarObject
00029 
00030 class HeatFlux_VU_3D(scalarObject): # 146-VUPENTA, 147-VUTETRA, 148-VUPENTA
00031     def __init__(self,dataCode,isSort1,iSubcase,dt):
00032         scalarObject.__init__(self,dataCode,iSubcase)
00033         #self.eType = {}
00034         self.parent = {}
00035 
00036         self.grad  = {}
00037         self.flux  = {}
00038 
00039         ## @todo if dt=None, handle SORT1 case
00040         if isSort1:
00041             if dt is not None:
00042                 self.add = self.addSort1
00043             ###
00044         else:
00045             assert dt is not None
00046             self.add = self.addSort2
00047         ###
00048 
00049     def addNewTransient(self,dt):
00050         self.grad[dt] = {}
00051         self.flux[dt] = {}
00052 
00053     def add(self,nNodes,dt,data):
00054         [eid,parent,gradFluxes] = data
00055         self.parent[eid] = parent
00056         #self.eType[eid]    = eType
00057         
00058         self.grad[eid] = {}
00059         self.flux[eid] = {}
00060         for gradFlux in gradFluxes:
00061             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00062             self.grad[eid][nid] = [xGrad,yGrad,zGrad]
00063             self.flux[eid][nid] = [xFlux,yFlux,zFlux]
00064 
00065     def addSort1(self,nNodes,dt,data):
00066         [eid,parent,gradFluxes] = data
00067         if dt not in self.grad:
00068             self.addNewTransient(dt)
00069         self.parent[eid] = parent
00070         #self.eType[eid]    = eType
00071         
00072         self.grad[dt][eid] = {}
00073         self.flux[dt][eid] = {}
00074         for gradFlux in gradFluxes:
00075             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00076             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00077             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00078 
00079     def addSort2(self,nNodes,eid,data):
00080         [dt,parent,gradFluxes] = data
00081         if dt not in self.fApplied:
00082             self.addNewTransient(dt)
00083         self.parent[eid] = parent
00084         self.coord[eid] = coord
00085         self.icord[eid] = icord
00086         self.theta[eid] = theta
00087         #self.eType[eid]    = eType
00088 
00089         self.grad[dt][eid] = {}
00090         self.flux[dt][eid] = {}
00091         for gradFlux in gradFluxes:
00092             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00093             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00094             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00095 
00096     def __repr__(self):
00097         return str(self.grad)
00098 
00099 class HeatFlux_VU(scalarObject): #  # 189-VUQUAD 190-VUTRIA,191-VUBEAM
00100     def __init__(self,dataCode,isSort1,iSubcase,dt):
00101         scalarObject.__init__(self,dataCode,iSubcase)
00102         #self.eType = {}
00103         self.parent = {}
00104         self.coord = {}
00105         self.icord = {}
00106         self.theta = {}
00107         
00108         self.grad  = {}
00109         self.flux  = {}
00110 
00111         ## @todo if dt=None, handle SORT1 case
00112         if isSort1:
00113             if dt is not None:
00114                 self.add = self.addSort1
00115             ###
00116         else:
00117             assert dt is not None
00118             self.add = self.addSort2
00119         ###
00120 
00121     def addNewTransient(self,dt):
00122         self.grad[dt] = {}
00123         self.flux[dt] = {}
00124 
00125     def add(self,nNodes,dt,data):
00126         [eid,parent,coord,icord,theta,gradFluxes] = data
00127         self.parent[eid] = parent
00128         self.coord[eid] = coord
00129         self.icord[eid] = icord
00130         self.theta[eid] = theta
00131         #self.eType[eid]    = eType
00132         
00133         self.grad[eid] = {}
00134         self.flux[eid] = {}
00135         for gradFlux in gradFluxes:
00136             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00137             self.grad[eid][nid] = [xGrad,yGrad,zGrad]
00138             self.flux[eid][nid] = [xFlux,yFlux,zFlux]
00139 
00140     def addSort1(self,nNodes,dt,data):
00141         [eid,parent,coord,icord,theta,gradFluxes] = data
00142         if dt not in self.grad:
00143             self.addNewTransient(dt)
00144         self.parent[eid] = parent
00145         self.coord[eid] = coord
00146         self.icord[eid] = icord
00147         self.theta[eid] = theta
00148         #self.eType[eid]    = eType
00149         
00150         self.grad[dt][eid] = {}
00151         self.flux[dt][eid] = {}
00152         for gradFlux in gradFluxes:
00153             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00154             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00155             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00156 
00157     def addSort2(self,nNodes,eid,data):
00158         [dt,parent,coord,icord,theta,gradFluxes] = data
00159         if dt not in self.fApplied:
00160             self.addNewTransient(dt)
00161         self.parent[eid] = parent
00162         self.coord[eid] = coord
00163         self.icord[eid] = icord
00164         self.theta[eid] = theta
00165         #self.eType[eid]    = eType
00166 
00167         self.grad[dt][eid] = {}
00168         self.flux[dt][eid] = {}
00169         for gradFlux in gradFluxes:
00170             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00171             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00172             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00173 
00174     def __repr__(self):
00175         return str(self.grad)
00176         
00177 class HeatFlux_VUBEAM(scalarObject): # 191-VUBEAM
00178     def __init__(self,dataCode,isSort1,iSubcase,dt):
00179         scalarObject.__init__(self,dataCode,iSubcase)
00180         #self.eType = {}
00181         self.parent = {}
00182         self.coord = {}
00183         self.icord = {}
00184         
00185         self.grad  = {}
00186         self.flux  = {}
00187 
00188         ## @todo if dt=None, handle SORT1 case
00189         if isSort1:
00190             if dt is not None:
00191                 self.add = self.addSort1
00192             ###
00193         else:
00194             assert dt is not None
00195             self.add = self.addSort2
00196         ###
00197 
00198     def addNewTransient(self,dt):
00199         self.grad[dt] = {}
00200         self.flux[dt] = {}
00201 
00202     def add(self,nNodes,dt,data):
00203         [eid,parent,coord,icord,gradFluxes] = data
00204         self.parent[eid] = parent
00205         self.coord[eid] = coord
00206         self.icord[eid] = icord
00207         #self.eType[eid]    = eType
00208         
00209         self.grad[eid] = {}
00210         self.flux[eid] = {}
00211         for gradFlux in gradFluxes:
00212             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00213             self.grad[eid][nid] = [xGrad,yGrad,zGrad]
00214             self.flux[eid][nid] = [xFlux,yFlux,zFlux]
00215 
00216     def addSort1(self,nNodes,dt,data):
00217         [eid,parent,coord,icord,gradFluxes] = data
00218         if dt not in self.grad:
00219             self.addNewTransient(dt)
00220         self.parent[eid] = parent
00221         self.coord[eid] = coord
00222         self.icord[eid] = icord
00223         #self.eType[eid]    = eType
00224         
00225         self.grad[dt][eid] = {}
00226         self.flux[dt][eid] = {}
00227         for gradFlux in gradFluxes:
00228             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00229             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00230             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00231 
00232     def addSort2(self,nNodes,eid,data):
00233         [dt,parent,coord,icord,gradFluxes] = data
00234         if dt not in self.fApplied:
00235             self.addNewTransient(dt)
00236         self.parent[eid] = parent
00237         self.coord[eid] = coord
00238         self.icord[eid] = icord
00239         #self.eType[eid]    = eType
00240 
00241         self.grad[dt][eid] = {}
00242         self.flux[dt][eid] = {}
00243         for gradFlux in gradFluxes:
00244             [nid,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = gradFlux
00245             self.grad[dt][eid][nid] = [xGrad,yGrad,zGrad]
00246             self.flux[dt][eid][nid] = [xFlux,yFlux,zFlux]
00247 
00248     def __repr__(self):
00249         return str(self.grad)
00250 
00251 class HeatFlux_1D(scalarObject): # 1-ROD, 2-BEAM, 3-TUBE, 10-CONROD, 34-BAR, 69-BEND
00252     def __init__(self,dataCode,isSort1,iSubcase,dt):
00253         scalarObject.__init__(self,dataCode,iSubcase)
00254         self.eType = {}
00255         self.grad  = {}
00256         self.flux  = {}
00257 
00258         ## @todo if dt=None, handle SORT1 case
00259         if isSort1:
00260             if dt is not None:
00261                 self.add = self.addSort1
00262             ###
00263         else:
00264             assert dt is not None
00265             self.add = self.addSort2
00266         ###
00267 
00268     def addNewTransient(self,dt):
00269         self.grad[dt] = {}
00270         self.flux[dt] = {}
00271 
00272     def add(self,dt,data):
00273         [eid,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = data
00274         self.eType[eid] = eType
00275         self.grad[eid]  = [xGrad,yGrad,zGrad]
00276         self.flux[eid]  = [xFlux,yFlux,zFlux]
00277 
00278     def addSort1(self,dt,data):
00279         [eid,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = data
00280         if dt not in self.grad:
00281             self.addNewTransient(dt)
00282         self.eType[eid]    = eType
00283         self.grad[dt][eid] = [xGrad,yGrad,zGrad]
00284         self.flux[dt][eid] = [xFlux,yFlux,zFlux]
00285 
00286     def addSort2(self,eid,data):
00287         [dt,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = data
00288         if dt not in self.fApplied:
00289             self.addNewTransient(dt)
00290         self.eType[eid]    = eType
00291         self.grad[dt][eid] = [xGrad,yGrad,zGrad]
00292         self.flux[dt][eid] = [xFlux,yFlux,zFlux]
00293 
00294     def __repr__(self):
00295         return str(self.grad)
00296         
00297 class HeatFlux_2D_3D(scalarObject):  # 33-QUAD4, 39-TETRA, 53-TRIAX6,64-QUAD8, 67-HEXA, 68-PENTA, 74-TRIA3, 75-TRIA6
00298     def __init__(self,dataCode,isSort1,iSubcase,dt):
00299         scalarObject.__init__(self,dataCode,iSubcase)
00300         self.eType = {}
00301         self.grad  = {}
00302         self.flux  = {}
00303 
00304         ## @todo if dt=None, handle SORT1 case
00305         if isSort1:
00306             self.add = self.addSort1
00307         else:
00308             self.add = self.addSort2
00309         ###
00310 
00311     def addNewTransient(self,dt):
00312         self.grad[dt] = {}
00313         self.flux[dt] = {}
00314 
00315     def addSort1(self,dt,data):
00316         [eid,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = data
00317         if dt not in self.grad:
00318             self.addNewTransient(dt)
00319         self.eType[eid]    = eType
00320         self.grad[dt][eid] = [xGrad,yGrad,zGrad]
00321         self.flux[dt][eid] = [xFlux,yFlux,zFlux]
00322 
00323     def addSort2(self,eid,data):
00324         [dt,eType,xGrad,yGrad,zGrad,xFlux,yFlux,zFlux] = data
00325         if dt not in self.fApplied:
00326             self.addNewTransient(dt)
00327         self.eType[eid]    = eType
00328         self.grad[dt][eid] = [xGrad,yGrad,zGrad]
00329         self.flux[dt][eid] = [xFlux,yFlux,zFlux]
00330 
00331     def __repr__(self):
00332         return str(self.grad)
00333         
00334 class HeatFlux_CONV(scalarObject): # 110-CONV
00335     def __init__(self,dataCode,isSort1,iSubcase,dt):
00336         scalarObject.__init__(self,dataCode,iSubcase)
00337         self.cntlNode  = {}
00338         self.freeConv  = {}
00339         self.freeConvK = {}
00340         
00341         ## @todo if dt=None, handle SORT1 case
00342         if isSort1:
00343             if dt is not None:
00344                 self.add = self.addSort1
00345             ###
00346         else:
00347             assert dt is not None
00348             self.add = self.addSort2
00349         ###
00350 
00351     def addNewTransient(self,dt):
00352         self.cntlNode[dt]  = {}
00353         self.freeConv[dt]  = {}
00354         self.freeConvK[dt] = {}
00355         
00356     def add(self,dt,data):
00357         [eid,cntlNode,freeConv,freeConvK] = data
00358         #self.eType[eid]     = eType
00359         self.cntlNode[eid]  = cntlNode
00360         self.freeConv[eid]  = freeConv
00361         self.freeConvK[eid] = freeConvK
00362 
00363     def addSort1(self,dt,data):
00364         [eid,cntlNode,freeConv,freeConvK] = data
00365         if dt not in self.freeConv:
00366             self.addNewTransient(dt)
00367         #self.eType[eid]     = eType
00368         self.cntlNode[dt][eid]  = cntlNode
00369         self.freeConv[dt][eid]  = freeConv
00370         self.freeConvK[dt][eid] = freeConvK
00371 
00372     def addSort2(self,eid,data):
00373         [dt,eType,fApplied,freeConv,forceConv,fRad,fTotal] = data
00374         if dt not in self.freeConv:
00375             self.addNewTransient(dt)
00376         #self.eType[eid]     = eType
00377         self.fApplied[dt][eid]  = fApplied
00378         self.freeConv[dt][eid]  = freeConv
00379         self.forceConv[dt][eid] = forceConv
00380         self.fRad[dt][eid]      = fRad
00381         self.fTotal[dt][eid]    = fTotal
00382 
00383     def __repr__(self):
00384         return str(self.fApplied)
00385 
00386 class HeatFlux_CHBDYx(scalarObject): # 107-CHBDYE 108-CHBDYG 109-CHBDYP
00387     def __init__(self,dataCode,isSort1,iSubcase,dt):
00388         scalarObject.__init__(self,dataCode,iSubcase)
00389         self.eType     = {}
00390         self.fApplied  = {}
00391         self.freeConv  = {}
00392         self.forceConv = {}
00393         self.fRad      = {}
00394         self.fTotal    = {}
00395         
00396         ## @todo if dt=None, handle SORT1 case
00397         if isSort1:
00398             if dt is not None:
00399                 self.add = self.addSort1
00400             ###
00401         else:
00402             assert dt is not None
00403             self.add = self.addSort2
00404         ###
00405 
00406     def addNewTransient(self,dt):
00407         self.fApplied[dt]  = {}
00408         self.freeConv[dt]  = {}
00409         self.forceConv[dt] = {}
00410         self.fRad[dt]      = {}
00411         self.fTotal[dt]    = {}
00412         
00413     def add(self,dt,data):
00414         [eid,eType,fApplied,freeConv,forceConv,fRad,fTotal] = data
00415 
00416         self.eType[eid]     = eType
00417         self.fApplied[eid]  = fApplied
00418         self.freeConv[eid]  = freeConv
00419         self.forceConv[eid] = forceConv
00420         self.fRad[eid]      = fRad
00421         self.fTotal[eid]    = fTotal
00422 
00423     def addSort1(self,dt,data):
00424         [eid,eType,fApplied,freeConv,forceConv,fRad,fTotal] = data
00425         if dt not in self.fApplied:
00426             self.addNewTransient(dt)
00427         self.eType[eid]     = eType
00428         self.fApplied[dt][eid]  = fApplied
00429         self.freeConv[dt][eid]  = freeConv
00430         self.forceConv[dt][eid] = forceConv
00431         self.fRad[dt][eid]      = fRad
00432         self.fTotal[dt][eid]    = fTotal
00433 
00434     def addSort2(self,eid,data):
00435         [dt,eType,fApplied,freeConv,forceConv,fRad,fTotal] = data
00436         if dt not in self.fApplied:
00437             self.addNewTransient(dt)
00438         self.eType[eid]     = eType
00439         self.fApplied[dt][eid]  = fApplied
00440         self.freeConv[dt][eid]  = freeConv
00441         self.forceConv[dt][eid] = forceConv
00442         self.fRad[dt][eid]      = fRad
00443         self.fTotal[dt][eid]    = fTotal
00444 
00445     def __repr__(self):
00446         return str(self.fApplied)
 All Classes Namespaces Files Functions Variables