pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
oef_forceObjects.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 from pyNastran.op2.resultObjects.op2_Objects import scalarObject
00028 
00029 class RealRodForce(scalarObject): # 1-ROD, 3-TUBE, 10-CONROD
00030     def __init__(self,dataCode,isSort1,iSubcase,dt):
00031         scalarObject.__init__(self,dataCode,iSubcase)
00032         #self.eType = {}
00033         self.axialForce = {}
00034         self.torque = {}
00035 
00036         self.dt = dt
00037         if isSort1:
00038             if dt is not None:
00039                 self.add = self.addSort1
00040             ###
00041         else:
00042             assert dt is not None
00043             self.add = self.addSort2
00044         ###
00045 
00046     def addNewTransient(self,dt):
00047         self.dt = dt
00048         self.axialForce[dt] = {}
00049         self.torque[dt] = {}
00050 
00051     def add(self,dt,data):
00052         [eid,axialForce,torque] = data
00053 
00054         #self.eType[eid] = eType
00055         self.axialForce[eid] = axialForce
00056         self.torque[eid] = torque
00057 
00058     def addSort1(self,dt,data):
00059         [eid,axialForce,torque] = data
00060         if dt not in self.axialForce:
00061             self.addNewTransient(dt)
00062 
00063         #self.eType[eid] = eType
00064         self.axialForce[dt][eid] = axialForce
00065         self.torque[dt][eid] = torque
00066 
00067     def addSort2(self,eid,data):
00068         [dt,axialForce,torque] = data
00069         if dt not in self.axialForce:
00070             self.addNewTransient(dt)
00071 
00072         #self.eType[eid] = eType
00073         self.axialForce[dt][eid] = axialForce
00074         self.torque[dt][eid] = torque
00075 
00076     def __repr__(self):
00077         return str(self.axialForce)
00078 
00079 class RealCBeamForce(scalarObject): # 2-CBEAM
00080     def __init__(self,dataCode,isSort1,iSubcase,dt):
00081         scalarObject.__init__(self,dataCode,iSubcase)
00082         #self.eType = {}
00083         self.nodes = {}
00084         self.bendingMoment = {}
00085         self.shear = {}
00086         self.axial = {}
00087         self.totalTorque = {}
00088         self.warpingTorque = {}
00089 
00090         self.dt = dt
00091         if isSort1:
00092             if dt is not None:
00093                 self.addNewElement = self.addNewElementSort1
00094                 self.add = self.addSort1
00095             ###
00096         else:
00097             assert dt is not None
00098             self.addNewElement = self.addNewElementSort2
00099             self.add = self.addSort2
00100         ###
00101 
00102     def addNewTransient(self,dt):
00103         self.dt = dt
00104         self.bendingMoment[dt] = {}
00105         self.shear[dt] = {}
00106         self.axial[dt] = {}
00107         self.totalTorque[dt] = {}
00108         self.warpingTorque[dt] = {}
00109 
00110     def addNewElement(self,dt,data):
00111         [eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00112         #print "CBEAM addnew",data
00113         #self.eType[eid] = eType
00114         self.nodes[eid] = {sd:[nid]}
00115         self.bendingMoment[eid] = {sd:[bm1,bm2]}
00116         self.shear[eid] = {sd:[ts1,ts2]}
00117         self.axial[eid] = {sd:af}
00118         self.totalTorque[eid] = {sd:ttrq}
00119         self.warpingTorque[eid] = {sd:wtrq}
00120 
00121     def add(self,dt,data):
00122         [eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00123         #print "CBEAM add   ",data
00124 
00125         #self.eType[eid] = eType
00126         self.nodes[eid][sd] = nid
00127         self.bendingMoment[eid][sd] = [bm1,bm2]
00128         self.shear[eid][sd] = [ts1,ts2]
00129         self.axial[eid][sd] = af
00130         self.totalTorque[eid][sd] = ttrq
00131         self.warpingTorque[eid][sd] = wtrq
00132 
00133     def addNewElementSort1(self,dt,data):
00134         [eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00135         self._fillObjectNew(dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq)
00136 
00137     def addSort1(self,dt,data):
00138         [eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00139         self._fillObject(dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq)
00140 
00141     def addNewElementSort2(self,eid,data):
00142         [dt,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00143         self._fillObjectNew(dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq)
00144         
00145     def addSort2(self,eid,data):
00146         [dt,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq] = data
00147         self._fillObject(dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq)
00148 
00149     def _fillObject(self,dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq):
00150         #if dt not in self.axial:
00151             #self.addNewTransient(dt)
00152         #self.eType[eid] = eType
00153         self.nodes[eid][sd] = nid
00154         self.bendingMoment[dt][eid][sd] = [bm1,bm2]
00155         self.shear[dt][eid][sd] = [ts1,ts2]
00156         self.axial[dt][eid][sd] = af
00157         self.totalTorque[dt][eid][sd] = ttrq
00158         self.warpingTorque[dt][eid][sd] = wtrq
00159 
00160     def _fillObjectNew(self,dt,eid,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq):
00161         if dt not in self.axial:
00162             self.addNewTransient(dt)
00163         #self.eType[eid] = eType
00164         self.nodes[eid] = {sd: nid}
00165         self.bendingMoment[dt][eid] = {sd:[bm1,bm2]}
00166         self.shear[dt][eid] = {sd:[ts1,ts2]}
00167         self.axial[dt][eid] = {sd:af}
00168         self.totalTorque[dt][eid] = {sd:ttrq}
00169         self.warpingTorque[dt][eid] = {sd:wtrq}
00170 
00171     def writeF06Transient(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00172         words = ['                                 F O R C E S   I N   B E A M   E L E M E N T S        ( C B E A M )\n',
00173                  '                    STAT DIST/   - BENDING MOMENTS -            - WEB  SHEARS -           AXIAL          TOTAL          WARPING\n',
00174                  '   ELEMENT-ID  GRID   LENGTH    PLANE 1       PLANE 2        PLANE 1       PLANE 2        FORCE          TORQUE         TORQUE\n']
00175         
00176         msg = []
00177         for dt,bms in sorted(self.bendingMoment.iteritems()):
00178             header[1] = ' %s = %10.4E\n' %(self.dataCode['name'],dt)
00179             msg+= header+words
00180             for eid,bm in sorted(bms.iteritems()):
00181                 for sd in sorted(bm):
00182                     nid = self.nodes[eid][sd]
00183                     bm1,bm2 = self.bendingMoment[dt][eid][sd]
00184                     ts1,ts2 = self.shear[dt][eid][sd]
00185                     af = self.axial[dt][eid][sd]
00186                     ttrq = self.totalTorque[dt][eid][sd]
00187                     wtrq = self.warpingTorque[dt][eid][sd]
00188                     (vals2,isAllZeros) = self.writeFloats13E([bm1,bm2,ts1,ts2,af,ttrq,wtrq])
00189                     [bm1,bm2,ts1,ts2,af,ttrq,wtrq] = vals2
00190 
00191                     if sd==0.:
00192                         msg.append('0  %8i\n' %(eid))
00193                     
00194                     ## @todo store grid ID
00195                     msg.append('           %8i   %.3f   %13s %13s  %13s %13s  %13s  %13s  %-s\n' %(nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq))
00196                 ###
00197             msg.append(pageStamp+str(pageNum)+'\n')
00198             if f is not None:
00199                 f.write(''.join(msg))
00200                 msg = ['']
00201             pageNum+=1
00202         return (''.join(msg),pageNum-1)
00203 
00204     def writeF06(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00205         if self.nonlinearFactor is not None:
00206             return self.writeF06Transient(header,pageStamp,pageNum,f)
00207         msg = header+['                                 F O R C E S   I N   B E A M   E L E M E N T S        ( C B E A M )\n',
00208                       '                    STAT DIST/   - BENDING MOMENTS -            - WEB  SHEARS -           AXIAL          TOTAL          WARPING\n',
00209                       '   ELEMENT-ID  GRID   LENGTH    PLANE 1       PLANE 2        PLANE 1       PLANE 2        FORCE          TORQUE         TORQUE\n']
00210         for eid,bm in sorted(self.bendingMoment.iteritems()):
00211             for sd in sorted(bm):
00212                 bm1,bm2 = self.bendingMoment[eid][sd]
00213                 ts1,ts2 = self.shear[eid][sd]
00214                 af = self.axial[eid][sd]
00215                 ttrq = self.totalTorque[eid][sd]
00216                 wtrq = self.warpingTorque[eid][sd]
00217                 (vals2,isAllZeros) = self.writeFloats13E([bm1,bm2,ts1,ts2,af,ttrq,wtrq])
00218                 [bm1,bm2,ts1,ts2,af,ttrq,wtrq] = vals2
00219                 msg.append('0  %8i\n' %(eid))
00220                 msg.append('           %8i   %.3f   %13s %13s  %13s %13s  %13s  %13s  %-s\n' %(eid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq))
00221             ###
00222         msg.append(pageStamp+str(pageNum)+'\n')
00223         if f is not None:
00224             f.write(''.join(msg))
00225             msg = ['']
00226         return (''.join(msg),pageNum)
00227 
00228     def __repr__(self):
00229         #return str(self.axial)
00230         return self.writeF06(['',''],'PAGE',1)
00231 
00232 class RealCShearForce(scalarObject): # 4-CSHEAR
00233     def __init__(self,dataCode,isSort1,iSubcase,dt):
00234         scalarObject.__init__(self,dataCode,iSubcase)
00235         #self.eType = {}
00236         self.force41 = {}
00237         self.force14 = {}
00238         self.force21 = {}
00239         self.force12 = {}
00240         self.force32 = {}
00241         self.force23 = {}
00242         self.force43 = {}
00243         self.force34 = {}
00244         self.kickForce1 = {}
00245         self.kickForce2 = {}
00246         self.kickForce3 = {}
00247         self.kickForce4 = {}
00248         self.shear12 = {}
00249         self.shear23 = {}
00250         self.shear34 = {}
00251         self.shear41 = {}
00252 
00253         self.dt = dt
00254         if isSort1:
00255             if dt is not None:
00256                 self.add = self.addSort1
00257             ###
00258         else:
00259             assert dt is not None
00260             self.add = self.addSort2
00261         ###
00262 
00263     def addNewTransient(self,dt):
00264         self.dt = dt
00265         self.force41[dt] = {}
00266         self.force14[dt] = {}
00267         self.force21[dt] = {}
00268         self.force12[dt] = {}
00269         self.force32[dt] = {}
00270         self.force23[dt] = {}
00271         self.force43[dt] = {}
00272         self.force34[dt] = {}
00273         self.kickForce1[dt] = {}
00274         self.kickForce2[dt] = {}
00275         self.kickForce3[dt] = {}
00276         self.kickForce4[dt] = {}
00277         self.shear12[dt] = {}
00278         self.shear23[dt] = {}
00279         self.shear34[dt] = {}
00280         self.shear41[dt] = {}
00281 
00282     def add(self,dt,data):
00283         [eid,f41,f21,f12,f32,f23,f43,f34,f14,
00284              kf1,s12,kf2,s23,kf3,s34,kf4,s41] = data
00285         #self.eType[eid] = eType
00286         self.force41[eid] = f41
00287         self.force14[eid] = f14
00288         self.force21[eid] = f21
00289         self.force12[eid] = f12
00290         self.force32[eid] = f32
00291         self.force23[eid] = f23
00292         self.force43[eid] = f43
00293         self.force34[eid] = f34
00294         self.kickForce1[eid] = kf1
00295         self.kickForce2[eid] = kf2
00296         self.kickForce3[eid] = kf3
00297         self.kickForce4[eid] = kf4
00298         self.shear12[eid] = s12
00299         self.shear23[eid] = s23
00300         self.shear34[eid] = s34
00301         self.shear41[eid] = s41
00302         
00303     def addSort1(self,dt,data):
00304         [eid,f41,f21,f12,f32,f23,f43,f34,f14,
00305              kf1,s12,kf2,s23,kf3,s34,kf4,s41] = data
00306         self._fillObject(dt,eid,f41,f21,f12,f32,f23,f43,f34,f14,
00307                                 kf1,s12,kf2,s23,kf3,s34,kf4,s41)
00308 
00309     def addSort2(self,eid,data):
00310         [dt,f41,f21,f12,f32,f23,f43,f34,f14,
00311             kf1,s12,kf2,s23,kf3,s34,kf4,s41] = data
00312 
00313         self._fillObject(dt,eid,f41,f21,f12,f32,f23,f43,f34,f14,
00314                                 kf1,s12,kf2,s23,kf3,s34,kf4,s41)
00315 
00316     def _fillObject(self,dt,eid,f41,f21,f12,f32,f23,f43,f34,f14,
00317                                 kf1,s12,kf2,s23,kf3,s34,kf4,s41):
00318         if dt not in self.force41:
00319             self.addNewTransient(dt)
00320         #self.eType[eid] = eType
00321         self.force41[dt][eid] = f41
00322         self.force14[dt][eid] = f14
00323         self.force21[dt][eid] = f21
00324         self.force12[dt][eid] = f12
00325         self.force32[dt][eid] = f32
00326         self.force23[dt][eid] = f23
00327         self.force43[dt][eid] = f43
00328         self.force34[dt][eid] = f34
00329         self.kickForce1[dt][eid] = kf1
00330         self.kickForce2[dt][eid] = kf2
00331         self.kickForce3[dt][eid] = kf3
00332         self.kickForce4[dt][eid] = kf4
00333         self.shear12[dt][eid] = s12
00334         self.shear23[dt][eid] = s23
00335         self.shear34[dt][eid] = s34
00336         self.shear41[dt][eid] = s41
00337 
00338     def __repr__(self):
00339         return str(self.force41)
00340 
00341 class RealSpringForce(scalarObject): # 11-CELAS1,12-CELAS2,13-CELAS3, 14-CELAS4
00342     def __init__(self,dataCode,isSort1,iSubcase,dt):
00343         scalarObject.__init__(self,dataCode,iSubcase)
00344         #self.eType = {}
00345         self.force = {}
00346 
00347         self.dt = dt
00348         if isSort1:
00349             if dt is not None:
00350                 self.add = self.addSort1
00351             ###
00352         else:
00353             assert dt is not None
00354             self.add = self.addSort2
00355         ###
00356 
00357     def addNewTransient(self,dt):
00358         self.dt = dt
00359         self.force[dt] = {}
00360 
00361     def add(self,dt,data):
00362         [eid,force] = data
00363 
00364         #self.eType[eid] = eType
00365         self.force[eid] = force
00366 
00367     def addSort1(self,dt,data):
00368         [eid,force] = data
00369         if dt not in self.force:
00370             self.addNewTransient(dt)
00371 
00372         #self.eType[eid] = eType
00373         self.force[dt][eid] = force
00374 
00375     def addSort2(self,eid,data):
00376         [dt,force] = data
00377         if dt not in self.force:
00378             self.addNewTransient(dt)
00379 
00380         #self.eType[eid] = eType
00381         self.force[dt][eid] = force
00382 
00383     def writeF06Transient(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00384         words = ['                              F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )\n',
00385                  ' \n',
00386                  '        TIME          FORCE              TIME          FORCE              TIME          FORCE              TIME          FORCE\n']
00387         msg = []
00388         for dt,Force in sorted(self.force.items()):
00389             header[1] = ' %s = %10.4E\n' %(self.dataCode['name'],dt)
00390             msg += header+words
00391 
00392             #packs = []
00393             forces = []
00394             elements = []
00395             line = '   '
00396             for eid,force in sorted(Force.items()):
00397                 elements.append(eid)
00398                 forces.append(force)
00399                 #pack.append(eid)
00400                 #pack.append(f)
00401                 line += '%13s  %13s     ' %(eid,f)
00402                 if len(forces)==3:
00403                     msg.append(line.rstrip()+'\n')
00404                 ###
00405             ###
00406             if forces:
00407                 msg.append(line.rstrip()+'\n')
00408             ###
00409             msg.append(pageStamp+str(pageNum)+'\n')
00410             if f is not None:
00411                 f.write(''.join(msg))
00412                 msg = ['']
00413             pageNum+=1
00414         ###
00415         return (''.join(msg),pageNum-1)
00416         
00417 
00418     def writeF06(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00419         if self.nonlinearFactor is not None:
00420             return self.writeF06Transient(header,pageStamp,pageNum,f)
00421         msg = header+['                              F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )\n',
00422                       ' \n',
00423                       '        TIME          FORCE              TIME          FORCE              TIME          FORCE              TIME          FORCE\n']
00424         #packs = []
00425         forces = []
00426         elements = []
00427         line = '   '
00428         for eid,force in sorted(self.force.items()):
00429             elements.append(eid)
00430             forces.append(force)
00431             #pack.append(eid)
00432             #pack.append(f)
00433             line += '%13s  %13s     ' %(eid,force)
00434             if len(forces)==3:
00435                 msg.append(line.rstrip()+'\n')
00436             ###
00437         ###
00438         if forces:
00439             msg.append(line.rstrip()+'\n')
00440         ###
00441         msg.append(pageStamp+str(pageNum)+'\n')
00442 
00443         if f is not None:
00444             f.write(''.join(msg))
00445             msg = ['']
00446         return (''.join(msg),pageNum)
00447 
00448     def __repr__(self):
00449         return str(self.force)
00450 
00451 class RealDamperForce(scalarObject):  # 20-CDAMP1,21-CDAMP2,22-CDAMP3,23-CDAMP4
00452     def __init__(self,dataCode,isSort1,iSubcase,dt):
00453         scalarObject.__init__(self,dataCode,iSubcase)
00454         #self.eType = {}
00455         self.force = {}
00456 
00457         self.dt = dt
00458         if isSort1:
00459             if dt is not None:
00460                 self.add = self.addSort1
00461             ###
00462         else:
00463             assert dt is not None
00464             self.add = self.addSort2
00465         ###
00466 
00467     def addNewTransient(self,dt):
00468         self.dt = dt
00469         self.force[dt] = {}
00470 
00471     def add(self,dt,data):
00472         [eid,force] = data
00473 
00474         #self.eType[eid] = eType
00475         self.force[eid] = force
00476 
00477     def addSort1(self,dt,data):
00478         [eid,force] = data
00479         if dt not in self.force:
00480             self.addNewTransient(dt)
00481 
00482         #self.eType[eid] = eType
00483         self.force[dt][eid] = force
00484 
00485     def addSort2(self,eid,data):
00486         [dt,force] = data
00487         if dt not in self.force:
00488             self.addNewTransient(dt)
00489 
00490         #self.eType[eid] = eType
00491         self.force[dt][eid] = force
00492 
00493     def writeF06Transient(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00494         words = ['                              F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )\n',
00495                  ' \n',
00496                  '        TIME          FORCE              TIME          FORCE              TIME          FORCE              TIME          FORCE\n']
00497         msg = []
00498         for dt,Force in sorted(self.force.items()):
00499             header[1] = ' %s = %10.4E\n' %(self.dataCode['name'],dt)
00500             msg += header+words
00501 
00502             #packs = []
00503             forces = []
00504             elements = []
00505             line = '   '
00506             for eid,force in sorted(Force.items()):
00507                 elements.append(eid)
00508                 forces.append(force)
00509                 #pack.append(eid)
00510                 #pack.append(f)
00511                 line += '%13s  %13s     ' %(eid,f)
00512                 if len(forces)==3:
00513                     msg.append(line.rstrip()+'\n')
00514                 ###                
00515             ###
00516             if forces:
00517                 msg.append(line.rstrip()+'\n')
00518             ###
00519             msg.append(pageStamp+str(pageNum)+'\n')
00520             if f is not None:
00521                 f.write(''.join(msg))
00522                 msg = ['']
00523             pageNum+=1
00524         ###
00525         return (''.join(msg),pageNum-1)
00526         
00527 
00528     def writeF06(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00529         if self.nonlinearFactor is not None:
00530             return self.writeF06Transient(header,pageStamp,pageNum,f)
00531         msg = header+['                              F O R C E S   I N   S C A L A R   S P R I N G S        ( C E L A S 2 )\n',
00532                       ' \n',
00533                       '        TIME          FORCE              TIME          FORCE              TIME          FORCE              TIME          FORCE\n']
00534         #packs = []
00535         forces = []
00536         elements = []
00537         line = '   '
00538         for eid,force in sorted(self.force.items()):
00539             elements.append(eid)
00540             forces.append(force)
00541             #pack.append(eid)
00542             #pack.append(f)
00543             line += '%13s  %13s     ' %(eid,force)
00544             if len(forces)==3:
00545                 msg.append(line.rstrip()+'\n')
00546             ###                
00547         ###
00548         if forces:
00549             msg.append(line.rstrip()+'\n')
00550         ###
00551         msg.append(pageStamp+str(pageNum)+'\n')
00552 
00553         if f is not None:
00554             f.write(''.join(msg))
00555             msg = ['']
00556         return (''.join(msg),pageNum)
00557 
00558     def __repr__(self):
00559         return str(self.force)
00560 
00561 class RealViscForce(scalarObject): # 24-CVISC
00562     def __init__(self,dataCode,isSort1,iSubcase,dt):
00563         scalarObject.__init__(self,dataCode,iSubcase)
00564         #self.eType = {}
00565         self.axialForce = {}
00566         self.torque = {}
00567 
00568         self.dt = dt
00569         if isSort1:
00570             if dt is not None:
00571                 self.add = self.addSort1
00572             ###
00573         else:
00574             assert dt is not None
00575             self.add = self.addSort2
00576         ###
00577 
00578     def addNewTransient(self,dt):
00579         self.dt = dt
00580         self.axialForce[dt] = {}
00581         self.torque[dt] = {}
00582 
00583     def add(self,dt,data):
00584         [eid,axialForce,torque] = data
00585 
00586         #self.eType[eid] = eType
00587         self.axialForce[eid] = axialForce
00588         self.torque[eid] = torque
00589 
00590     def addSort1(self,dt,data):
00591         [eid,axialForce,torque] = data
00592         if dt not in self.axialForce:
00593             self.addNewTransient(dt)
00594 
00595         #self.eType[eid] = eType
00596         self.axialForce[dt][eid] = axialForce
00597         self.torque[dt][eid] = torque
00598 
00599     def addSort2(self,eid,data):
00600         [dt,axialForce,torque] = data
00601         if dt not in self.axialForce:
00602             self.addNewTransient(dt)
00603 
00604         #self.eType[eid] = eType
00605         self.axialForce[dt][eid] = axialForce
00606         self.torque[dt][eid] = torque
00607 
00608     def __repr__(self):
00609         return str(self.axialForce)
00610 
00611 class RealPlateForce(scalarObject): # 33-CQUAD4, 74-CTRIA3
00612     def __init__(self,dataCode,isSort1,iSubcase,dt):
00613         scalarObject.__init__(self,dataCode,iSubcase)
00614         #self.eType = {}
00615         self.mx = {}
00616         self.my = {}
00617         self.mxy = {}
00618         self.bmx = {}
00619         self.bmy = {}
00620         self.bmxy = {}
00621         self.tx = {}
00622         self.ty = {}
00623 
00624         self.dt = dt
00625         if isSort1:
00626             if dt is not None:
00627                 self.add = self.addSort1
00628             ###
00629         else:
00630             assert dt is not None
00631             self.add = self.addSort2
00632         ###
00633 
00634     def addNewTransient(self,dt):
00635         self.dt = dt
00636         self.mx[dt] = {}
00637         self.my[dt] = {}
00638         self.mxy[dt] = {}
00639         self.bmx[dt] = {}
00640         self.bmy[dt] = {}
00641         self.bmxy[dt] = {}
00642         self.tx[dt] = {}
00643         self.ty[dt] = {}
00644 
00645     def add(self,dt,data):
00646         [eid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00647 
00648         #self.eType[eid] = eType
00649         self.mx[eid] = mx
00650         self.my[eid] = my
00651         self.mxy[eid] = mxy
00652         self.bmx[eid] = bmx
00653         self.bmy[eid] = bmy
00654         self.bmxy[eid] = bmxy
00655         self.tx[eid] = tx
00656         self.ty[eid] = ty
00657 
00658     def addSort1(self,dt,data):
00659         [eid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00660         if dt not in self.mx:
00661             self.addNewTransient(dt)
00662 
00663         #self.eType[eid] = eType
00664         self.mx[dt][eid] = mx
00665         self.my[dt][eid] = my
00666         self.mxy[dt][eid] = mxy
00667         self.bmx[dt][eid] = bmx
00668         self.bmy[dt][eid] = bmy
00669         self.bmxy[dt][eid] = bmxy
00670         self.tx[dt][eid] = tx
00671         self.ty[dt][eid] = ty
00672 
00673     def addSort2(self,eid,data):
00674         [dt,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00675         if dt not in self.mx:
00676             self.addNewTransient(dt)
00677 
00678         #self.eType[eid] = eType
00679         self.mx[dt][eid] = mx
00680         self.my[dt][eid] = my
00681         self.mxy[dt][eid] = mxy
00682         self.bmx[dt][eid] = bmx
00683         self.bmy[dt][eid] = bmy
00684         self.bmxy[dt][eid] = bmxy
00685         self.tx[dt][eid] = tx
00686         self.ty[dt][eid] = ty
00687 
00688     def __repr__(self):
00689         return str(self.mx)
00690 
00691 class RealPLATE2Force(scalarObject): # 64-CQUAD8, 75-CTRIA6, 82-CQUADR
00692     def __init__(self,dataCode,isSort1,iSubcase,dt):
00693         scalarObject.__init__(self,dataCode,iSubcase)
00694         #self.eType = {}
00695         self.term = {}
00696         self.ngrids = {}
00697         self.mx = {}
00698         self.my = {}
00699         self.mxy = {}
00700         self.bmx = {}
00701         self.bmy = {}
00702         self.bmxy = {}
00703         self.tx = {}
00704         self.ty = {}
00705 
00706         self.dt = dt
00707         if isSort1:
00708             if dt is not None:
00709                 self.addNewElement = self.addNewElementSort1
00710                 self.add = self.addSort1
00711             ###
00712         else:
00713             assert dt is not None
00714             self.addNewElement = self.addNewElementSort2
00715             self.add = self.addSort2
00716         ###
00717 
00718     def addNewTransient(self,dt):
00719         self.dt = dt
00720         self.mx[dt] = {}
00721         self.my[dt] = {}
00722         self.mxy[dt] = {}
00723         self.bmx[dt] = {}
00724         self.bmy[dt] = {}
00725         self.bmxy[dt] = {}
00726         self.tx[dt] = {}
00727         self.ty[dt] = {}
00728 
00729     def addNewElement(self,eid,dt,data):
00730         #print "eid = ",eid
00731         [term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00732 
00733         #self.eType[eid] = eType
00734         self.term[eid] = term
00735         self.ngrids[eid] = nid
00736 
00737         self.mx[eid] = [mx]
00738         self.my[eid] = [my]
00739         self.mxy[eid] = [mxy]
00740         self.bmx[eid] = [bmx]
00741         self.bmy[eid] = [bmy]
00742         self.bmxy[eid] = [bmxy]
00743         self.tx[eid] = [tx]
00744         self.ty[eid] = [ty]
00745 
00746     def add(self,eid,dt,data):
00747         [nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00748 
00749         #self.eType[eid] = eType
00750         #print "mx = ",self.mx,mx
00751         self.mx[eid].append(mx)
00752         self.my[eid].append(my)
00753         self.mxy[eid].append(mxy)
00754         self.bmx[eid].append(bmx)
00755         self.bmy[eid].append(bmy)
00756         self.bmxy[eid].append(bmxy)
00757         self.tx[eid].append(tx)
00758         self.ty[eid].append(ty)
00759 
00760     def addNewElementSort1(self,eid,dt,data):
00761         [term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00762         if dt not in self.mx:
00763             self.addNewTransient(dt)
00764 
00765         #self.eType[eid] = eType
00766         self.term[eid] = term
00767         self.ngrids[eid] = nid
00768         self.mx[dt][eid] = [mx]
00769         self.my[dt][eid] = [my]
00770         self.mxy[dt][eid] = [mxy]
00771         self.bmx[dt][eid] = [bmx]
00772         self.bmy[dt][eid] = [bmy]
00773         self.bmxy[dt][eid] = [bmxy]
00774         self.tx[dt][eid] = [tx]
00775         self.ty[dt][eid] = [ty]
00776 
00777     def addSort1(self,eid,dt,data):
00778         [nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00779         if dt not in self.mx:
00780             self.addNewTransient(dt)
00781 
00782         #self.eType[eid] = eType
00783         self.mx[dt][eid].append(mx)
00784         self.my[dt][eid].append(my)
00785         self.mxy[dt][eid].append(mxy)
00786         self.bmx[dt][eid].append(bmx)
00787         self.bmy[dt][eid].append(bmy)
00788         self.bmxy[dt][eid].append(bmxy)
00789         self.tx[dt][eid].append(tx)
00790         self.ty[dt][eid].append(ty)
00791 
00792     def addNewElementSort2(self,dt,eid,data):
00793         [term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00794         if dt not in self.mx:
00795             self.addNewTransient(dt)
00796 
00797         #self.eType[eid] = eType
00798         self.term[eid] = term
00799         self.ngrids[eid] = nid
00800 
00801         self.mx[dt][eid] = [mx]
00802         self.my[dt][eid] = [my]
00803         self.mxy[dt][eid] = [mxy]
00804         self.bmx[dt][eid] = [bmx]
00805         self.bmy[dt][eid] = [bmy]
00806         self.bmxy[dt][eid] = [bmxy]
00807         self.tx[dt][eid] = [tx]
00808         self.ty[dt][eid] = [ty]
00809 
00810     def addSort2(self,dt,eid,data):
00811         [nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty] = data
00812         if dt not in self.mx:
00813             self.addNewTransient(dt)
00814 
00815         #self.eType[eid] = eType
00816         self.mx[dt][eid].append(mx)
00817         self.my[dt][eid].append(my)
00818         self.mxy[dt][eid].append(mxy)
00819         self.bmx[dt][eid].append(bmx)
00820         self.bmy[dt][eid].append(bmy)
00821         self.bmxy[dt][eid].append(bmxy)
00822         self.tx[dt][eid].append(tx)
00823         self.ty[dt][eid].append(ty)
00824 
00825     def __repr__(self):
00826         return str(self.mx)
00827 
00828 class RealCBARForce(scalarObject): # 34-CBAR
00829     def __init__(self,dataCode,isSort1,iSubcase,dt):
00830         scalarObject.__init__(self,dataCode,iSubcase)
00831         #self.eType = {}
00832         self.bendingMomentA = {}
00833         self.bendingMomentB = {}
00834         self.shear = {}
00835         self.axial = {}
00836         self.torque = {}
00837 
00838         self.dt = dt
00839         if isSort1:
00840             if dt is not None:
00841                 self.add = self.addSort1
00842             ###
00843         else:
00844             assert dt is not None
00845             self.add = self.addSort2
00846         ###
00847 
00848     def addNewTransient(self,dt):
00849         self.dt = dt
00850         self.bendingMomentA[dt] = {}
00851         self.bendingMomentB[dt] = {}
00852         self.shear[dt] = {}
00853         self.axial[dt] = {}
00854         self.torque[dt] = {}
00855 
00856     def add(self,dt,data):
00857         [eid,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq] = data
00858 
00859         #self.eType[eid] = eType
00860         self.bendingMomentA[eid] = [bm1a,bm2a]
00861         self.bendingMomentB[eid] = [bm1b,bm2b]
00862         self.shear[eid] = [ts1,ts2]
00863         self.axial[eid] = af
00864         self.torque[eid] = trq
00865 
00866     def addSort1(self,dt,data):
00867         [eid,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq] = data
00868         if dt not in self.axial:
00869             self.addNewTransient(dt)
00870 
00871         #self.eType[eid] = eType
00872         self.bendingMomentA[dt][eid] = [bm1a,bm2a]
00873         self.bendingMomentB[dt][eid] = [bm1b,bm2b]
00874         self.shear[dt][eid] = [ts1,ts2]
00875         self.axial[dt][eid] = af
00876         self.torque[dt][eid] = trq
00877 
00878     def addSort2(self,eid,data):
00879         [dt,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq] = data
00880         if dt not in self.axial:
00881             self.addNewTransient(dt)
00882 
00883         #self.eType[eid] = eType
00884         self.bendingMomentA[dt][eid] = [bm1a,bm2a]
00885         self.bendingMomentB[dt][eid] = [bm1b,bm2b]
00886         self.shear[dt][eid] = [ts1,ts2]
00887         self.axial[dt][eid] = af
00888         self.torque[dt][eid] = trq
00889 
00890     def writeF06Transient(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
00891         words = ['                                 F O R C E S   I N   B A R   E L E M E N T S         ( C B A R )\n',
00892                  '0    ELEMENT         BEND-MOMENT END-A            BEND-MOMENT END-B                - SHEAR -               AXIAL\n',
00893                  '       ID.         PLANE 1       PLANE 2        PLANE 1       PLANE 2        PLANE 1       PLANE 2         FORCE         TORQUE\n']
00894         msg = []
00895         for dt,bm in sorted(self.bendingMomentA.iteritems()):
00896             header[1] = ' %s = %10.4E\n' %(self.dataCode['name'],dt)
00897             msg+= header+words
00898             for eid in sorted(bm):
00899                 bm1a,bm2a = self.bendingMomentA[dt][eid]
00900                 bm1b,bm2b = self.bendingMomentB[dt][eid]
00901                 ts1,ts2 = self.shear[dt][eid]
00902                 af = self.axial[dt][eid]
00903                 trq = self.torque[dt][eid]
00904                 (vals2,isAllZeros) = self.writeFloats13E([bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq])
00905                 [bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq] = vals2
00906                 msg.append('      %8i    %13s %13s  %13s %13s  %13s %13s  %13s  %-s\n' %(eid,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq))
00907 #            1     2.504029E+06  9.728743E+06   5.088001E+05  1.976808E+06   1.995229E+06  7.751935E+06  -3.684978E-07  -1.180941E-07
00908             ###
00909             msg.append(pageStamp+str(pageNum)+'\n')
00910             if f is not None:
00911                 f.write(''.join(msg))
00912                 msg = ['']
00913             pageNum+=1
00914         ###
00915         return (''.join(msg),pageNum-1)
00916 
00917     def __repr__(self):
00918         return str(self.axial)
00919 
00920 class RealCBAR100Force(scalarObject): # 100-CBAR
00921     def __init__(self,dataCode,isSort1,iSubcase,dt):
00922         scalarObject.__init__(self,dataCode,iSubcase)
00923         #self.eType = {}
00924         self.bendingMoment = {}
00925         self.shear = {}
00926         self.axial = {}
00927         self.torque = {}
00928 
00929         self.dt = dt
00930         if isSort1:
00931             if dt is not None:
00932                 self.add = self.addSort1
00933             ###
00934         else:
00935             assert dt is not None
00936             self.add = self.addSort2
00937         ###
00938 
00939     def addNewTransient(self,dt):
00940         self.dt = dt
00941         self.bendingMoment[dt] = {}
00942         self.shear[dt] = {}
00943         self.axial[dt] = {}
00944         self.torque[dt] = {}
00945 
00946     def add(self,dt,data):
00947         [eid,sd,bm1,bm2,ts1,ts2,af,trq] = data
00948 
00949         #self.eType[eid] = eType
00950         self.bendingMoment[eid] = [bm1,bm2]
00951         self.shear[eid] = [ts1,ts2]
00952         self.axial[eid] = af
00953         self.torque[eid] = trq
00954 
00955     def addSort1(self,dt,data):
00956         [eid,sd,bm1,bm2,ts1,ts2,af,trq] = data
00957         if dt not in self.axial:
00958             self.addNewTransient(dt)
00959 
00960         #self.eType[eid] = eType
00961         self.bendingMoment[dt][eid] = [bm1,bm2]
00962         self.shear[dt][eid] = [ts1,ts2]
00963         self.axial[dt][eid] = af
00964         self.torque[dt][eid] = trq
00965 
00966     def addSort2(self,eid,data):
00967         [dt,sd,bm1,bm2,ts1,ts2,af,trq] = data
00968         if dt not in self.axial:
00969             self.addNewTransient(dt)
00970 
00971         #self.eType[eid] = eType
00972         self.bendingMoment[dt][eid] = [bm1,bm2]
00973         self.shear[dt][eid] = [ts1,ts2]
00974         self.axial[dt][eid] = af
00975         self.torque[dt][eid] = trq
00976 
00977     def __repr__(self):
00978         return str(self.axial)
00979 
00980 class RealConeAxForce(scalarObject): # 35-CCONEAX
00981     def __init__(self,dataCode,isSort1,iSubcase,dt):
00982         scalarObject.__init__(self,dataCode,iSubcase)
00983         #self.eType = {}
00984         self.hopa = {}
00985         self.bmu = {}
00986         self.bmv = {}
00987         self.tm = {}
00988         self.su = {}
00989         self.sv = {}
00990 
00991         self.dt = dt
00992         if isSort1:
00993             if dt is not None:
00994                 self.add = self.addSort1
00995             ###
00996         else:
00997             assert dt is not None
00998             self.add = self.addSort2
00999         ###
01000 
01001     def addNewTransient(self,dt):
01002         self.dt = dt
01003         self.hopa[dt] = {}
01004         self.bmu[dt] = {}
01005         self.bmv[dt] = {}
01006         self.tm[dt] = {}
01007         self.su[dt] = {}
01008         self.sv[dt] = {}
01009 
01010     def add(self,dt,data):
01011         [eid,hopa,bmu,bmv,tm,su,sv] = data
01012 
01013         #self.eType[eid] = eType
01014         self.hopa[eid] = hopa
01015         self.bmu[eid] = bmu
01016         self.bmv[eid] = bmv
01017         self.tm[eid] = tm
01018         self.su[eid] = su
01019         self.sv[eid] = sv
01020 
01021     def addSort1(self,dt,data):
01022         [eid,hopa,bmu,bmv,tm,su,sv] = data
01023         if dt not in self.hopa:
01024             self.addNewTransient(dt)
01025 
01026         #self.eType[eid] = eType
01027         self.hopa[dt][eid] = hopa
01028         self.bmu[dt][eid] = bmu
01029         self.bmv[dt][eid] = bmv
01030         self.tm[dt][eid] = tm
01031         self.su[dt][eid] = su
01032         self.sv[dt][eid] = sv
01033 
01034     def addSort2(self,eid,data):
01035         [dt,hopa,bmu,bmv,tm,su,sv] = data
01036         if dt not in self.hopa:
01037             self.addNewTransient(dt)
01038 
01039         #self.eType[eid] = eType
01040         self.hopa[dt][eid] = hopa
01041         self.bmu[dt][eid] = bmu
01042         self.bmv[dt][eid] = bmv
01043         self.tm[dt][eid] = tm
01044         self.su[dt][eid] = su
01045         self.sv[dt][eid] = sv
01046 
01047     def __repr__(self):
01048         return str(self.hopa)
01049 
01050 class RealCGAPForce(scalarObject): # 38-CGAP
01051     def __init__(self,dataCode,isSort1,iSubcase,dt):
01052         scalarObject.__init__(self,dataCode,iSubcase)
01053         #self.eType = {}
01054         self.fx = {}
01055         self.sfy = {}
01056         self.sfz = {}
01057         self.u = {}
01058         self.v = {}
01059         self.w = {}
01060         self.sv = {}
01061         self.sw = {}
01062 
01063         self.dt = dt
01064         if isSort1:
01065             if dt is not None:
01066                 self.add = self.addSort1
01067             ###
01068         else:
01069             assert dt is not None
01070             self.add = self.addSort2
01071         ###
01072 
01073     def addNewTransient(self,dt):
01074         self.dt = dt
01075         self.fx[dt] = {}
01076         self.sfy[dt] = {}
01077         self.sfz[dt] = {}
01078         self.u[dt] = {}
01079         self.v[dt] = {}
01080         self.w[dt] = {}
01081         self.sv[dt] = {}
01082         self.sw[dt] = {}
01083 
01084     def add(self,dt,data):
01085         [eid,fx,sfy,sfz,u,v,w,sv,sw] = data
01086 
01087         #self.eType[eid] = eType
01088         self.fx[eid] = fx
01089         self.sfy[eid] = sfy
01090         self.sfz[eid] = sfz
01091         self.u[eid] = u
01092         self.v[eid] = v
01093         self.w[eid] = w
01094         self.sv[eid] = sv
01095         self.sw[eid] = sw
01096 
01097     def addSort1(self,dt,data):
01098         [eid,fx,sfy,sfz,u,v,w,sv,sw] = data
01099         if dt not in self.fx:
01100             self.addNewTransient(dt)
01101 
01102         #self.eType[eid] = eType
01103         self.fx[dt][eid] = fx
01104         self.sfy[dt][eid] = sfy
01105         self.sfz[dt][eid] = sfz
01106         self.u[dt][eid] = u
01107         self.v[dt][eid] = v
01108         self.w[dt][eid] = w
01109         self.sv[dt][eid] = sv
01110         self.sw[dt][eid] = sw
01111 
01112     def addSort2(self,eid,data):
01113         [dt,fx,sfy,sfz,u,v,w,sv,sw] = data
01114         if dt not in self.fx:
01115             self.addNewTransient(dt)
01116 
01117         #self.eType[eid] = eType
01118         self.fx[dt][eid] = fx
01119         self.sfy[dt][eid] = sfy
01120         self.sfz[dt][eid] = sfz
01121         self.u[dt][eid] = u
01122         self.v[dt][eid] = v
01123         self.w[dt][eid] = w
01124         self.sv[dt][eid] = sv
01125         self.sw[dt][eid] = sw
01126 
01127     def __repr__(self):
01128         return str(self.fx)
01129 
01130 class RealBendForce(scalarObject): # 69-CBEND
01131     def __init__(self,dataCode,isSort1,iSubcase,dt):
01132         scalarObject.__init__(self,dataCode,iSubcase)
01133         #self.eType = {}
01134         self.nodeIDs = {}
01135         self.bendingMoment1 = {}
01136         self.bendingMoment2 = {}
01137         self.shearPlane1 = {}
01138         self.shearPlane2 = {}
01139         self.axial  = {}
01140         self.torque = {}
01141         
01142         self.dt = dt
01143         if isSort1:
01144             if dt is not None:
01145                 self.add = self.addSort1
01146             ###
01147         else:
01148             assert dt is not None
01149             self.add = self.addSort2
01150         ###
01151 
01152     def addNewTransient(self,dt):
01153         self.dt = dt
01154         self.bendingMoment1[dt] = {}
01155         self.bendingMoment2[dt] = {}
01156         self.shearPlane1[dt] = {}
01157         self.shearPlane2[dt] = {}
01158         self.axial[dt]  = {}
01159         self.torque[dt] = {}
01160 
01161     def add(self,dt,data):
01162         [eid,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01163              nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB] = data
01164 
01165         #self.eType[eid] = eType
01166         self.nodeIDs[eid] = [nidA,nidB]
01167         self.bendingMoment1[eid] = [bm1A,bm1B]
01168         self.bendingMoment2[eid] = [bm2A,bm2B]
01169         self.shearPlane1[eid] = [sp1A,sp1B]
01170         self.shearPlane2[eid] = [sp2A,sp2B]
01171         self.axial[eid]  = [axialA,axialB]
01172         self.torque[eid] = [torqueA,torqueB]
01173 
01174     def addSort1(self,dt,data):
01175         [eid,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01176              nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB] = data
01177         self._fillObject(dt,eid,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01178                                 nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB)
01179 
01180     def addSort2(self,eid,data):
01181         [dt,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01182             nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB] = data
01183         self._fillObject(dt,eid,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01184                                 nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB)
01185 
01186     def _fillObject(self,dt,eid,nidA,bm1A,bm2A,sp1A,sp2A,axialA,torqueA,
01187                                 nidB,bm1B,bm2B,sp1B,sp2B,axialB,torqueB):
01188         if dt not in self.axial:
01189             self.addNewTransient(dt)
01190 
01191         #self.eType[eid] = eType
01192         self.nodeIDs[eid] = [nidA,nidB]
01193         self.bendingMoment1[dt][eid] = [bm1A,bm1B]
01194         self.bendingMoment2[dt][eid] = [bm2A,bm2B]
01195         self.shearPlane1[dt][eid] = [sp1A,sp1B]
01196         self.shearPlane2[dt][eid] = [sp2A,sp2B]
01197         self.axial[dt][eid]  = [axialA,axialB]
01198         self.torque[dt][eid] = [torqueA,torqueB]
01199 
01200     def __repr__(self):
01201         return str(self.axial)
01202 
01203 class RealPentaPressureForce(scalarObject): # 77-PENTA_PR,78-TETRA_PR
01204     def __init__(self,dataCode,isSort1,iSubcase,dt):
01205         scalarObject.__init__(self,dataCode,iSubcase)
01206         #self.eType = {}
01207         self.acceleration = {}
01208         self.velocity = {}
01209         self.pressure = {}
01210 
01211         self.dt = dt
01212         if isSort1:
01213             if dt is not None:
01214                 self.add = self.addSort1
01215             ###
01216         else:
01217             assert dt is not None
01218             self.add = self.addSort2
01219         ###
01220 
01221     def addNewTransient(self,dt):
01222         self.dt = dt
01223         self.acceleration[dt] = {}
01224         self.velocity[dt] = {}
01225         self.pressure[dt] = {}
01226 
01227     def add(self,dt,data):
01228         [eid,eName,ax,ay,az,vx,vy,vz,pressure] = data
01229 
01230         #self.eType[eid] = eType
01231         self.acceleration[eid] = [ax,ay,az]
01232         self.velocity[eid] = [vx,vy,vz]
01233         self.pressure[eid] = pressure
01234 
01235     def addSort1(self,dt,data):
01236         [eid,eName,ax,ay,az,vx,vy,vz,pressure] = data
01237         if dt not in self.acceleration:
01238             self.addNewTransient(dt)
01239 
01240         #self.eType[eid] = eType
01241         self.acceleration[dt][eid] = [ax,ay,az]
01242         self.velocity[dt][eid] = [vx,vy,vz]
01243         self.pressure[dt][eid] = pressure
01244 
01245     def addSort2(self,eid,data):
01246         [dt,eName,ax,ay,az,vx,vy,vz,pressure] = data
01247         if dt not in self.acceleration:
01248             self.addNewTransient(dt)
01249 
01250         #self.eType[eid] = eType
01251         self.acceleration[dt][eid] = [ax,ay,az]
01252         self.velocity[dt][eid] = [vx,vy,vz]
01253         self.pressure[dt][eid] = pressure
01254 
01255     def writeF06(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
01256         #words = ['                                   P E A K   A C C E L E R A T I O N S   A N D   P R E S S U R E S\n',
01257         #         ' \n',
01258         #         '    TIME         EL-TYPE             X-ACCELERATION            Y-ACCELERATION            Z-ACCELERATION            PRESSURE (DB)\n']
01259         if self.nonlinearFactor is not None:
01260             return self.writeF06Transient(header,pageStamp,pageNum,f)
01261         return 'RealPentaPressureForce writeF06 not implemented...\n'
01262         #raise NotImplementedError()
01263 
01264     def writeF06Transient(self,header,pageStamp,pageNum=1,f=None,isMagPhase=False):
01265         words = ['                                   P E A K   A C C E L E R A T I O N S   A N D   P R E S S U R E S\n',
01266                  ' \n',
01267                  '    TIME         EL-TYPE             X-ACCELERATION            Y-ACCELERATION            Z-ACCELERATION            PRESSURE (DB)\n']
01268         msg = []
01269         for dt,acc in sorted(self.acceleration.items()):
01270             header[1] = ' %s = %10.4E\n' %(self.dataCode['name'],dt)
01271             msg += header+words
01272             for eid in sorted(acc):
01273                 ax,ay,az = self.acceleration[dt][eid]
01274                 vx,vy,vz = self.velocity[dt][eid]
01275                 pressure = self.pressure[dt][eid]
01276                 vals = [ax,ay,az,pressure]
01277                 (vals2,isAllZeros) = self.writeFloats13E(vals)
01278                 [ax,ay,az,pressure] = vals2
01279                 eType = 'PENPR'
01280                 msg.append('0%13s    %5s               %13s             %13s             %13s             %-s\n' %(eid,eType,ax,ay,az,pressure))
01281             ###
01282             msg.append(pageStamp+str(pageNum)+'\n')
01283             if f is not None:
01284                 f.write(''.join(msg))
01285                 msg = ['']
01286             pageNum+=1
01287         return (''.join(msg),pageNum-1)
01288 
01289     def __repr__(self):
01290         return str(self.acceleration)
01291 
01292 class RealCBUSHForce(scalarObject): # 102-CBUSH
01293     def __init__(self,dataCode,isSort1,iSubcase,dt):
01294         scalarObject.__init__(self,dataCode,iSubcase)
01295         #self.eType = {}
01296         self.force = {}
01297         self.moment = {}
01298 
01299         self.dt = dt
01300         if isSort1:
01301             if dt is not None:
01302                 self.add = self.addSort1
01303             ###
01304         else:
01305             assert dt is not None
01306             self.add = self.addSort2
01307         ###
01308 
01309     def addNewTransient(self,dt):
01310         self.dt = dt
01311         self.force[dt] = {}
01312         self.moment[dt] = {}
01313 
01314     def add(self,dt,data):
01315         [eid,fx,fy,fz,mx,my,mz] = data
01316 
01317         #self.eType[eid] = eType
01318         self.force[eid] = [fx,fy,fz]
01319         self.moment[eid] = [mx,my,mz]
01320 
01321     def addSort1(self,dt,data):
01322         [eid,fx,fy,fz,mx,my,mz] = data
01323         if dt not in self.force:
01324             self.addNewTransient(dt)
01325 
01326         #self.eType[eid] = eType
01327         self.force[dt][eid] = [fx,fy,fz]
01328         self.moment[dt][eid] = [mx,my,mz]
01329 
01330     def addSort2(self,eid,data):
01331         [dt,fx,fy,fz,mx,my,mz] = data
01332         if dt not in self.force:
01333             self.addNewTransient(dt)
01334 
01335         #self.eType[eid] = eType
01336         self.force[dt][eid] = [fx,fy,fz]
01337         self.moment[dt][eid] = [mx,my,mz]
01338 
01339     def __repr__(self):
01340         return str(self.force)
01341 
01342 class RealForce_VU(scalarObject): # 191-VUBEAM
01343     def __init__(self,dataCode,isSort1,iSubcase,dt):
01344         scalarObject.__init__(self,dataCode,iSubcase)
01345         #self.eType = {}
01346         self.parent = {}
01347         self.coord = {}
01348         self.icord = {}
01349         
01350         self.forceX  = {}
01351         self.shearY  = {}
01352         self.shearZ  = {}
01353         self.torsion  = {}
01354         self.bendingY  = {}
01355         self.bendingZ  = {}
01356 
01357         ## @todo if dt=None, handle SORT1 case
01358         self.dt = dt
01359         if isSort1:
01360             if dt is not None:
01361                 self.add = self.addSort1
01362             ###
01363         else:
01364             assert dt is not None
01365             self.add = self.addSort2
01366         ###
01367 
01368     def addNewTransient(self,dt):
01369         self.dt = dt
01370         self.forceX[dt]  = {}
01371         self.shearY[dt]  = {}
01372         self.shearZ[dt]  = {}
01373         self.torsion[dt]  = {}
01374         self.bendingY[dt]  = {}
01375         self.bendingZ[dt]  = {}
01376 
01377     def add(self,nNodes,dt,data):
01378         [eid,parent,coord,icord,forces] = data
01379         self.parent[eid] = parent
01380         self.coord[eid] = coord
01381         self.icord[eid] = icord
01382         #self.eType[eid]    = eType
01383         
01384         self.forceX[eid]  = {}
01385         self.shearY[eid]  = {}
01386         self.shearZ[eid]  = {}
01387         self.torsion[eid]  = {}
01388         self.bendingY[eid] = {}
01389         self.bendingZ[eid] = {}
01390 
01391         for force in forces:
01392             [nid,posit,forceX,shearY,shearZ,torsion,bendingY,bendingZ] = force
01393             self.forceX[eid][nid]  = forceX
01394             self.shearY[eid][nid]  = shearY
01395             self.shearZ[eid][nid]  = shearZ
01396             self.torsion[eid][nid]  = torsion
01397             self.bendingY[eid][nid] = bendingY
01398             self.bendingZ[eid][nid] = bendingZ
01399 
01400     def addSort1(self,nNodes,dt,data):
01401         [eid,parent,coord,icord,forces] = data
01402         if dt not in self.forceX:
01403             self.addNewTransient(dt)
01404         self.parent[eid] = parent
01405         self.coord[eid] = coord
01406         self.icord[eid] = icord
01407         #self.eType[eid]    = eType
01408         
01409         self.forceX[dt][eid]  = {}
01410         self.shearY[dt][eid]  = {}
01411         self.shearZ[dt][eid]  = {}
01412         self.torsion[dt][eid]  = {}
01413         self.bendingY[dt][eid] = {}
01414         self.bendingZ[dt][eid] = {}
01415 
01416         for force in forces:
01417             [nid,posit,forceX,shearY,shearZ,torsion,bendingY,bendingZ] = force
01418             self.forceX[dt][eid][nid]  = forceX
01419             self.shearY[dt][eid][nid]  = shearY
01420             self.shearZ[dt][eid][nid]  = shearZ
01421             self.torsion[dt][eid][nid]  = torsion
01422             self.bendingY[dt][eid][nid] = bendingY
01423             self.bendingZ[dt][eid][nid] = bendingZ
01424 
01425     def addSort2(self,nNodes,eid,data):
01426         [dt,parent,coord,icord,forces] = data
01427         if dt not in self.forceX:
01428             self.addNewTransient(dt)
01429         self.parent[eid] = parent
01430         self.coord[eid] = coord
01431         self.icord[eid] = icord
01432         #self.eType[eid]    = eType
01433 
01434         self.forceX[dt][eid]  = {}
01435         self.shearY[dt][eid]  = {}
01436         self.shearZ[dt][eid]  = {}
01437         self.torsion[dt][eid]  = {}
01438         self.bendingY[dt][eid] = {}
01439         self.bendingZ[dt][eid] = {}
01440         for force in forces:
01441             [nid,posit,forceX,shearY,shearZ,torsion,bendingY,bendingZ] = force
01442             self.forceX[dt][eid][nid]  = forceX
01443             self.shearY[dt][eid][nid]  = shearY
01444             self.shearZ[dt][eid][nid]  = shearZ
01445             self.torsion[dt][eid][nid]  = torsion
01446             self.bendingY[dt][eid][nid] = bendingY
01447             self.bendingZ[dt][eid][nid] = bendingZ
01448 
01449     def __repr__(self):
01450         return str(self.forceX)
01451 
01452 class RealForce_VU_2D(scalarObject): # 190-VUTRIA # 189-VUQUAD
01453     def __init__(self,dataCode,isSort1,iSubcase,dt):
01454         scalarObject.__init__(self,dataCode,iSubcase)
01455         #self.eType = {}
01456         self.parent = {}
01457         self.coord = {}
01458         self.icord = {}
01459         self.theta = {}
01460         
01461         self.membraneX  = {}
01462         self.membraneY  = {}
01463         self.membraneXY = {}
01464         self.bendingX  = {}
01465         self.bendingY  = {}
01466         self.bendingXY = {}
01467         self.shearYZ = {}
01468         self.shearXZ = {}
01469 
01470         ## @todo if dt=None, handle SORT1 case
01471         self.dt = dt
01472         if isSort1:
01473             if dt is not None:
01474                 self.add = self.addSort1
01475             ###
01476         else:
01477             assert dt is not None
01478             self.add = self.addSort2
01479         ###
01480 
01481     def addNewTransient(self,dt):
01482         self.membraneX[dt]  = {}
01483         self.membraneY[dt]  = {}
01484         self.membraneXY[dt] = {}
01485         self.bendingX[dt]  = {}
01486         self.bendingY[dt]  = {}
01487         self.bendingXY[dt] = {}
01488         self.shearYZ[dt] = {}
01489         self.shearXZ[dt] = {}
01490 
01491     def add(self,nNodes,dt,data):
01492         [eid,parent,coord,icord,theta,forces] = data
01493         self.parent[eid] = parent
01494         self.coord[eid] = coord
01495         self.icord[eid] = icord
01496         self.theta[eid] = theta
01497         #self.eType[eid]    = eType
01498         
01499         self.membraneX[eid]  = {}
01500         self.membraneY[eid]  = {}
01501         self.membraneXY[eid] = {}
01502         self.bendingX[eid]  = {}
01503         self.bendingY[eid]  = {}
01504         self.bendingXY[eid] = {}
01505         self.shearYZ[eid] = {}
01506         self.shearXZ[eid] = {}
01507 
01508         for force in forces:
01509             [nid,membraneX,membraneY,membraneXY,bendingX,bendingY,bendingXY,shearYZ,shearXZ] = force
01510             self.membraneX[eid][nid]  = membraneX
01511             self.membraneY[eid][nid]  = membraneY
01512             self.membraneXY[eid][nid] = membraneXY
01513             self.bendingX[eid][nid]  = bendingX
01514             self.bendingY[eid][nid]  = bendingY
01515             self.bendingXY[eid][nid] = bendingXY
01516             self.shearYZ[eid][nid]  = shearYZ
01517             self.shearXZ[eid][nid]  = shearXZ
01518 
01519     def addSort1(self,nNodes,dt,data):
01520         [eid,parent,coord,icord,theta,forces] = data
01521         self._fillObject(dt,eid,parent,coord,icord,theta,forces)
01522 
01523     def addSort2(self,nNodes,eid,data):
01524         [dt,parent,coord,icord,theta,forces] = data
01525         self._fillObject(dt,eid,parent,coord,icord,theta,forces)
01526 
01527     def _fillObject(self,dt,eid,parent,coord,icord,theta,forces):
01528         if dt not in self.membraneX:
01529             self.addNewTransient(dt)
01530         self.parent[eid] = parent
01531         self.coord[eid] = coord
01532         self.icord[eid] = icord
01533         self.theta[eid] = theta
01534         #self.eType[eid]    = eType
01535 
01536         self.membraneX[dt][eid]  = {}
01537         self.membraneY[dt][eid]  = {}
01538         self.membraneXY[dt][eid] = {}
01539         self.bendingX[dt][eid]  = {}
01540         self.bendingY[dt][eid]  = {}
01541         self.bendingXY[dt][eid] = {}
01542         self.shearYZ[dt][eid] = {}
01543         self.shearXZ[dt][eid] = {}
01544 
01545         for force in forces:
01546             [nid,membraneX,membraneY,membraneXY,bendingX,bendingY,bendingXY,shearYZ,shearXZ] = force
01547             self.membraneX[dt][eid][nid]  = membraneX
01548             self.membraneY[dt][eid][nid]  = membraneY
01549             self.membraneXY[dt][eid][nid] = membraneXY
01550             self.bendingX[dt][eid][nid]  = bendingX
01551             self.bendingY[dt][eid][nid]  = bendingY
01552             self.bendingXY[dt][eid][nid] = bendingXY
01553             self.shearYZ[dt][eid][nid]  = shearYZ
01554             self.shearXZ[dt][eid][nid]  = shearXZ
01555 
01556     def __repr__(self):
01557         return str(self.membraneX)
 All Classes Namespaces Files Functions Variables