pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
complexForces.py
Go to the documentation of this file.
00001 ## GNU Lesser General Public License
00002 ## 
00003 ## Program pyNastran - a python interface to NASTRAN files
00004 ## Copyright (C) 2011-2012  Steven Doyle, Al Danial
00005 ## 
00006 ## Authors and copyright holders of pyNastran
00007 ## Steven Doyle <mesheb82@gmail.com>
00008 ## Al Danial    <al.danial@gmail.com>
00009 ## 
00010 ## This file is part of pyNastran.
00011 ## 
00012 ## pyNastran is free software: you can redistribute it and/or modify
00013 ## it under the terms of the GNU Lesser General Public License as published by
00014 ## the Free Software Foundation, either version 3 of the License, or
00015 ## (at your option) any later version.
00016 ## 
00017 ## pyNastran is distributed in the hope that it will be useful,
00018 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 ## GNU General Public License for more details.
00021 ## 
00022 ## You should have received a copy of the GNU Lesser General Public License
00023 ## along with pyNastran.  If not, see <http://www.gnu.org/licenses/>.
00024 ## 
00025 
00026 from __future__ import division, print_function
00027 #import sys
00028 from struct import unpack
00029 
00030 from pyNastran.op2.op2_helper import polarToRealImag
00031 
00032 class ComplexForces(object):
00033 
00034     def OEF_Rod_alt(self): # 1-CROD, 3-CTUBE, 10-CONROD
00035         #deviceCode = self.deviceCode
00036         dt = self.nonlinearFactor
00037         (format1,extract) = self.getOEF_FormatStart()
00038         format1 += '4f'
00039         format1 = bytes(format1)
00040         isMagnitudePhase = self.isMagnitudePhase()
00041 
00042         while len(self.data)>=20: # 5*4
00043             eData     = self.data[0:20]
00044             self.data = self.data[20: ]
00045             #print "len(data) = ",len(eData)
00046 
00047             out = unpack(format1, eData)
00048             (eid,axialReal,torqueReal,axialImag,torqueImag) = out
00049 
00050             if isMagnitudePhase:
00051                 (axial)   = polarToRealImag(axialReal,axialImag)
00052                 (torque) = polarToRealImag(torqueReal,torqueImag)
00053             else:
00054                 axial  = complex(axialReal,axialImag)
00055                 torque = complex(torqueReal,torqueImag)
00056             eid2  = extract(eid,dt)
00057             #print "eType=%s" %(eType)
00058             
00059             dataIn = [eid2,axial,torque]
00060             #print "%s" %(self.ElementType(self.elementType)),dataIn
00061             #eid = self.obj.addNewEid(out)
00062             self.obj.add(dt,dataIn)
00063             #print "len(data) = ",len(self.data)
00064         ###
00065         #print self.rodForces
00066         
00067     def OEF_Beam_alt(self): # 2-CBEAM
00068         dt = self.nonlinearFactor
00069         (format1,extract) = self.getOEF_FormatStart()
00070         isMagnitudePhase = self.isMagnitudePhase()
00071 
00072         #print self.codeInformation()
00073         #nTotal = 16*11+1
00074         formatAll = 'i15f'
00075         format1 = bytes(format1)
00076         formatAll = bytes(formatAll)
00077         while len(self.data)>=708: # (16*11+1)*4 = 177*4
00078             eData     = self.data[0:4]
00079             self.data = self.data[4: ]
00080             eidTemp, = unpack(format1, eData)
00081             eid2  = extract(eidTemp,dt)
00082 
00083             for i in xrange(11):
00084                 eData     = self.data[0:64]
00085                 self.data = self.data[64: ]
00086                 #print "len(data) = ",len(eData)
00087 
00088                 out = unpack(formatAll, eData)
00089                 (nid,sd,bm1r,bm2r,ts1r,ts2r,afr,ttrqr,wtrqr,
00090                         bm1i,bm2i,ts1i,ts2i,afi,ttrqi,wtrqi) = out
00091 
00092                 if isMagnitudePhase:
00093                     bm1  = polarToRealImag(bm1r,bm1i)
00094                     bm2  = polarToRealImag(bm2r,bm2i)
00095                     ts1  = polarToRealImag(ts1r,ts1i)
00096                     ts2  = polarToRealImag(ts2r,ts2i)
00097                     af   = polarToRealImag(afr,afi)
00098                     ttrq = polarToRealImag(ttrqr,ttrqi)
00099                     wtrq = polarToRealImag(wtrqr,wtrqi)
00100                 else:
00101                     bm1  = complex(bm1r,bm1i)
00102                     bm2  = complex(bm2r,bm2i)
00103                     ts1  = complex(ts1r,ts1i)
00104                     ts2  = complex(ts2r,ts2i)
00105                     af   = complex(afr,afi)
00106                     ttrq = complex(ttrqr,ttrqi)
00107                     wtrq = complex(wtrqr,wtrqi)
00108                 #print "eidTemp = ",eidTemp
00109                 #print "nid = ",nid
00110                 #print "sd = ",sd
00111 
00112                 #eid = self.obj.addNewEid(out)
00113                 if i==0: #isNewElement:
00114                     dataIn = [eid2,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq]
00115                     #print "%s cNew   " %(self.ElementType(self.elementType)),dataIn
00116                     self.obj.addNewElement(dt,dataIn)
00117                     #print
00118                 elif sd>0.:
00119                     dataIn = [eid2,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq]
00120                     #print "%s cOld   " %(self.ElementType(self.elementType)),dataIn
00121                     self.obj.add(dt,dataIn)
00122                     #print
00123                 #else: pass
00124 
00125             #print "len(data) = ",len(self.data)
00126         ###
00127         #print self.beamForces
00128 
00129     def OEF_Shear_alt(self): # 4-CSHEAR
00130         dt = self.nonlinearFactor
00131         (format1,extract) = self.getOEF_FormatStart()
00132         format1 += '32f'
00133         format1 = bytes(format1)
00134         isMagnitudePhase = self.isMagnitudePhase()
00135 
00136         while len(self.data)>=132: # 33*4
00137             eData     = self.data[0:132]
00138             self.data = self.data[132: ]
00139             #print "len(data) = ",len(eData)
00140 
00141             out = unpack(format1, eData)
00142             (eid,f41r,f21r,f12r,f32r,f23r,f43r,f34r,f14r,kf1r,s12r,kf2r,s23r,kf3r,s34r,kf4r,s41r,
00143                  f41i,f21i,f12i,f32i,f23i,f43i,f34i,f14i,kf1i,s12i,kf2i,s23i,kf3i,s34i,kf4i,s41i) = out
00144             if isMagnitudePhase:
00145                 f41r = polarToRealImag(f41r,f41i); kf1 = polarToRealImag(kf1r,kf1i)
00146                 f21r = polarToRealImag(f21r,f21i); kf2 = polarToRealImag(kf2r,kf2i)
00147                 f12r = polarToRealImag(f12r,f12i); kf3 = polarToRealImag(kf3r,kf3i)
00148                 f23r = polarToRealImag(f23r,f23i); kf4 = polarToRealImag(kf4r,kf4i)
00149                 f32r = polarToRealImag(f32r,f32i); s12 = polarToRealImag(s12r,s12i)
00150                 f43r = polarToRealImag(f43r,f43i); s23 = polarToRealImag(s23r,s23i)
00151                 f34r = polarToRealImag(f34r,f34i); s34 = polarToRealImag(s34r,s34i)
00152                 f14r = polarToRealImag(f14r,f14i); s41 = polarToRealImag(s41r,s41i)
00153             else:
00154                 f41 = complex(f41r, f41i); kf1 = complex(kf1r, kf1i)
00155                 f21 = complex(f21r, f21i); kf2 = complex(kf2r, kf2i)
00156                 f12 = complex(f12r, f12i); kf3 = complex(kf3r, kf3i)
00157                 f23 = complex(f23r, f23i); kf4 = complex(kf4r, kf4i)
00158                 f32 = complex(f32r, f32i); s12 = complex(s12r, s12i)
00159                 f43 = complex(f43r, f43i); s23 = complex(s23r, s23i)
00160                 f34 = complex(f34r, f34i); s34 = complex(s34r, s34i)
00161                 f14 = complex(f14r, f14i); s41 = complex(s41r, s41i)
00162             
00163             eid2  = extract(eid,dt)
00164             #print "eType=%s" %(eType)
00165             
00166             dataIn = [eid2, f41, f21, f12, f32, f23, f43, f34, f14,
00167                       kf1 ,s12, kf2, s23, kf3, s34, kf4, s41]
00168             #print "%s" %(self.ElementType(self.elementType)),dataIn
00169             #eid = self.obj.addNewEid(out)
00170             self.obj.add(dt,dataIn)
00171             #print "len(data) = ",len(self.data)
00172         ###
00173         #print self.shearForces
00174         
00175     def OEF_Spring_alt(self): # 11-CELAS1, 12-CELAS2, 13-CELAS3, 14-CELAS4
00176         dt = self.nonlinearFactor
00177         (format1,extract) = self.getOEF_FormatStart()
00178         format1 += 'ff'
00179         format1 = bytes(format1)
00180         isMagnitudePhase = self.isMagnitudePhase()
00181 
00182         while len(self.data)>=12: # 3*4
00183             eData     = self.data[0:12]
00184             self.data = self.data[12: ]
00185             #print "len(data) = ",len(eData)
00186 
00187             out = unpack(format1, eData)
00188             (eid,forceReal,forceImag) = out
00189             eid2  = extract(eid,dt)
00190             #print "eType=%s" %(eType)
00191             
00192             if isMagnitudePhase:
00193                 force = polarToRealImag(forceReal,forceImag)
00194             else:
00195                 force = complex(forceReal,forceImag)
00196 
00197             dataIn = [eid2,force]
00198             #print "%s" %(self.ElementType(self.elementType)),dataIn
00199             #eid = self.obj.addNewEid(out)
00200             self.obj.add(dt,dataIn)
00201             #print "len(data) = ",len(self.data)
00202         ###
00203         #print self.springForces
00204         
00205     def OEF_CVisc_alt(self): # 24-CVISC
00206         dt = self.nonlinearFactor
00207         (format1,extract) = self.getOEF_FormatStart()
00208         format1 += '4f'
00209         format1 = bytes(format1)
00210         isMagnitudePhase = self.isMagnitudePhase()
00211 
00212         while len(self.data)>=20: # 5*4
00213             eData     = self.data[0:20]
00214             self.data = self.data[20: ]
00215             #print "len(data) = ",len(eData)
00216 
00217             out = unpack(format1, eData)
00218             (eid,axialReal,torqueReal,axialImag,torqueImag) = out
00219             eid2  = extract(eid,dt)
00220             #print "eType=%s" %(eType)
00221 
00222             if isMagnitudePhase:
00223                 axial  = polarToRealImag(axialReal,axialImag)
00224                 torque = polarToRealImag(torqueReal,torqueImag)
00225             else:
00226                 axial  = complex(axialReal,axialImag)
00227                 torque = complex(torqueReal,torqueImag)
00228             
00229             dataIn = [eid2,axial,torque]
00230             #print "%s" %(self.ElementType(self.elementType)),dataIn
00231             #eid = self.obj.addNewEid(out)
00232             self.obj.add(dt,dataIn)
00233             #print "len(data) = ",len(self.data)
00234         ###
00235         #print self.viscForces
00236         
00237     def OEF_CBar_alt(self): # 34-CBAR
00238         dt = self.nonlinearFactor
00239         (format1,extract) = self.getOEF_FormatStart()
00240         format1 += '16f'
00241         format1 = bytes(format1)
00242         isMagnitudePhase = self.isMagnitudePhase()
00243 
00244         while len(self.data) >= 68: # 17*4
00245             eData     = self.data[0:68]
00246             self.data = self.data[68: ]
00247             #print "len(data) = ",len(eData)
00248 
00249             out = unpack(format1, eData)
00250             (eid,bm1ar,bm2ar,bm1br,bm2br,ts1r,ts2r,afr,trqr,
00251                  bm1ai,bm2ai,bm1bi,bm2bi,ts1i,ts2i,afi,trqi) = out
00252             eid2  = extract(eid,dt)
00253             #print "eType=%s" %(eType)
00254             
00255             if isMagnitudePhase:
00256                 bm1a = polarToRealImag(bm1ar,bm1ai)
00257                 bm2a = polarToRealImag(bm2ar,bm2ai)
00258                 bm1b = polarToRealImag(bm1br,bm1bi)
00259                 bm2b = polarToRealImag(bm2br,bm2bi)
00260                 ts1  = polarToRealImag(ts1r,ts1i)
00261                 ts2  = polarToRealImag(ts2r,ts2i)
00262                 af   = polarToRealImag(afr,afi)
00263                 trq  = polarToRealImag(trqr,trqi)
00264             else:
00265                 bm1a = complex(bm1ar,bm1ai)
00266                 bm2a = complex(bm2ar,bm2ai)
00267                 bm1b = complex(bm1br,bm1bi)
00268                 bm2b = complex(bm2br,bm2bi)
00269                 ts1  = complex(ts1r,ts1i)
00270                 ts2  = complex(ts2r,ts2i)
00271                 af   = complex(afr,afi)
00272                 trq  = complex(trqr,trqi)
00273 
00274             dataIn = [eid2,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq]
00275             #print "%s" %(self.ElementType(self.elementType)),dataIn
00276             #eid = self.obj.addNewEid(out)
00277             self.obj.add(dt,dataIn)
00278             #print "len(data) = ",len(self.data)
00279         ###
00280         #print self.barForces
00281         
00282     def OEF_Plate_alt(self): # 33-CQUAD4,74-CTRIA3
00283         dt = self.nonlinearFactor
00284         (format1,extract) = self.getOEF_FormatStart()
00285         format1 += '16f'
00286         format1 = bytes(format1)
00287         isMagnitudePhase = self.isMagnitudePhase()
00288 
00289         while len(self.data)>=68: # 17*4
00290             eData     = self.data[0:68]
00291             self.data = self.data[68: ]
00292             #print "len(data) = ",len(eData)
00293 
00294             out = unpack(format1, eData)
00295             (eid,mxr,myr,mxyr,bmxr,bmyr,bmxyr,txr,tyr,
00296                  mxi,myi,mxyi,bmxi,bmyi,bmxyi,txi,tyi) = out
00297             eid2  = extract(eid,dt)
00298             #print "eType=%s" %(eType)
00299             
00300             if isMagnitudePhase:
00301                 mx   = polarToRealImag(mxr,mxi)
00302                 my   = polarToRealImag(myr,myi)
00303                 mxy  = polarToRealImag(mxyr,mxyi)
00304                 bmx  = polarToRealImag(bmxr,bmxi)
00305                 bmy  = polarToRealImag(bmyr,bmyi)
00306                 bmxy = polarToRealImag(bmxyr,bmxyi)
00307                 tx   = polarToRealImag(txr,txi)
00308                 ty   = polarToRealImag(tyr,tyi)
00309             else:
00310                 mx   = complex(mxr,mxi)
00311                 my   = complex(myr,myi)
00312                 mxy  = complex(mxyr,mxyi)
00313                 bmx  = complex(bmxr,bmxi)
00314                 bmy  = complex(bmyr,bmyi)
00315                 bmxy = complex(bmxyr,bmxyi)
00316                 tx   = complex(txr,txi)
00317                 ty   = complex(tyr,tyi)
00318 
00319             dataIn = [eid2,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00320             #print "%s" %(self.ElementType(self.elementType)),dataIn
00321             #eid = self.obj.addNewEid(out)
00322             self.obj.add(dt,dataIn)
00323             #print "len(data) = ",len(self.data)
00324         ###
00325         #print self.plateForces
00326 
00327     def OEF_Plate2_alt(self): # 64-CQUAD8,70-CTRIAR,75-CTRIA6,82-CQUAD8,144-CQUAD4-bilinear
00328         dt = self.nonlinearFactor
00329         (format1,extract) = self.getOEF_FormatStart()
00330         format1 += '4s'
00331         isMagnitudePhase = self.isMagnitudePhase()
00332         
00333         if self.elementType in [70,75]: # CTRIAR,CTRIA6
00334             nNodes = 4
00335         elif self.elementType in [64,82,144]: # CQUAD8,CQUADR,CQUAD4-bilinear
00336             nNodes = 5
00337         else:
00338             raise NotImplementedError(self.codeInformation())
00339         ###
00340             
00341         allFormat = '17f'
00342         format1 = bytes(format1)
00343         allFormat = bytes(allFormat)
00344         nTotal = 8+nNodes*68
00345         while len(self.data)>=nTotal:
00346             eData     = self.data[0:76]
00347             self.data = self.data[76: ]
00348             #print self.printBlock(eData)
00349             #print "len(data) = ",len(eData)
00350 
00351             out = unpack(format1+allFormat, eData)
00352             (eid,term,nid,mxr,myr,mxyr,bmxr,bmyr,bmxyr,txr,tyr,
00353                           mxi,myi,mxyi,bmxi,bmyi,bmxyi,txi,tyi) = out
00354             #term = 'CEN\'
00355             #print "eType=%s" %(eType)
00356 
00357             eid2  = extract(eid,dt)
00358             
00359             if isMagnitudePhase:
00360                 mx   = polarToRealImag(mxr,mxi)
00361                 my   = polarToRealImag(myr,myi)
00362                 mxy  = polarToRealImag(mxyr,mxyi)
00363                 bmx  = polarToRealImag(bmxr,bmxi)
00364                 bmy  = polarToRealImag(bmyr,bmyi)
00365                 bmxy = polarToRealImag(bmxyr,bmxyi)
00366                 tx   = polarToRealImag(txr,txi)
00367                 ty   = polarToRealImag(tyr,tyi)
00368             else:
00369                 mx   = complex(mxr,mxi)
00370                 my   = complex(myr,myi)
00371                 mxy  = complex(mxyr,mxyi)
00372                 bmx  = complex(bmxr,bmxi)
00373                 bmy  = complex(bmyr,bmyi)
00374                 bmxy = complex(bmxyr,bmxyi)
00375                 tx   = complex(txr,txi)
00376                 ty   = complex(tyr,tyi)
00377 
00378             dataIn = [term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00379             #print "%s" %(self.ElementType(self.elementType)),dataIn
00380             self.obj.addNewElement(eid2,dt,dataIn)
00381 
00382             for i in xrange(nNodes-1):  ## @todo fix crash...
00383                 eData     = self.data[0:68]
00384                 self.data = self.data[68: ]
00385                 out = unpack(allFormat, eData)
00386 
00387                 (nid,mxr,myr,mxyr,bmxr,bmyr,bmxyr,txr,tyr,
00388                      mxi,myi,mxyi,bmxi,bmyi,bmxyi,txi,tyi) = out
00389                 if isMagnitudePhase:
00390                     mx   = polarToRealImag(mxr,mxi)
00391                     my   = polarToRealImag(myr,myi)
00392                     mxy  = polarToRealImag(mxyr,mxyi)
00393                     bmx  = polarToRealImag(bmxr,bmxi)
00394                     bmy  = polarToRealImag(bmyr,bmyi)
00395                     bmxy = polarToRealImag(bmxyr,bmxyi)
00396                     tx   = polarToRealImag(txr,txi)
00397                     ty   = polarToRealImag(tyr,tyi)
00398                 else:
00399                     mx   = complex(mxr,mxi)
00400                     my   = complex(myr,myi)
00401                     mxy  = complex(mxyr,mxyi)
00402                     bmx  = complex(bmxr,bmxi)
00403                     bmy  = complex(bmyr,bmyi)
00404                     bmxy = complex(bmxyr,bmxyi)
00405                     tx   = complex(txr,txi)
00406                     ty   = complex(tyr,tyi)
00407                 dataIn = [nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00408                 #print "***%s    " %(self.ElementType(self.elementType)),dataIn
00409                 
00410                 self.obj.add(eid2,dt,dataIn)
00411                 #print "len(data) = ",len(self.data)
00412             ###
00413         ###
00414         #print self.plateForces2
00415 
00416     def OEF_Bend_alt(self): # 69-CBEND
00417         dt = self.nonlinearFactor
00418         (format1,extract) = self.getOEF_FormatStart()
00419         format1 += 'i25f'
00420         format1 = bytes(format1)
00421         isMagnitudePhase = self.isMagnitudePhase()
00422 
00423         while len(self.data)>=108: # 27*4
00424             eData     = self.data[0:108]
00425             self.data = self.data[108: ]
00426             #print "len(data) = ",len(eData)
00427 
00428             out = unpack(format1, eData)
00429             (eid,nidA,bm1Ar,bm2Ar,ts1Ar,ts2Ar,afAr,trqAr,
00430                       bm1Ai,bm2Ai,ts1Ai,ts2Ai,afAi,trqAi,
00431                  nidB,bm1Br,bm2Br,ts1Br,ts2Br,afBr,trqBr,
00432                       bm1Bi,bm2Bi,ts1Bi,ts2Bi,afBi,trqBi) = out
00433             eid2  = extract(eid,dt)
00434             #print "eType=%s" %(eType)
00435             
00436             if isMagnitudePhase:
00437                 bm1A = polarToRealImag(bm1Ar,bm1Ai); bm1B = polarToRealImag(bm1Br,bm1Bi)
00438                 bm2A = polarToRealImag(bm2Ar,bm2Ai); bm2B = polarToRealImag(bm2Br,bm2Bi)
00439                 ts1A = polarToRealImag(ts1Ar,ts1Ai); ts1B = polarToRealImag(ts1Br,ts1Bi)
00440                 ts2A = polarToRealImag(ts2Ar,ts2Ai); ts2B = polarToRealImag(ts2Br,ts2Bi)
00441                 afA  = polarToRealImag(afAr, afAi);  afB  = polarToRealImag(afBr, afBi)
00442                 trqA = polarToRealImag(trqAr,trqAi); trqB = polarToRealImag(trqBr,trqBi)
00443             else:
00444                 bm1A = complex(bm1Ar,bm1Ai); bm1B = complex(bm1Br,bm1Bi)
00445                 bm2A = complex(bm2Ar,bm2Ai); bm2B = complex(bm2Br,bm2Bi)
00446                 ts1A = complex(ts1Ar,ts1Ai); ts1B = complex(ts1Br,ts1Bi)
00447                 ts2A = complex(ts2Ar,ts2Ai); ts2B = complex(ts2Br,ts2Bi)
00448                 afA  = complex(afAr, afAi);  afB  = complex(afBr, afBi)
00449                 trqA = complex(trqAr,trqAi); trqB = complex(trqBr,trqBi)
00450 
00451             dataIn = [eid2,nidA,bm1A,bm2A,ts1A,ts2A,afA,trqA,
00452                            nidB,bm1B,bm2B,ts1B,ts2B,afB,trqB]
00453             #print "%s" %(self.ElementType(self.elementType)),dataIn
00454             #eid = self.obj.addNewEid(out)
00455             self.obj.add(dt,dataIn)
00456             #print "len(data) = ",len(self.data)
00457         ###
00458         #print self.bendForces
00459         
00460     def OEF_PentaPressure_alt(self): # 76-CHEXA_PR,77-CPENTA_PR,78-CTETRA_PR
00461         dt = self.nonlinearFactor
00462         (format1,extract) = self.getOEF_FormatStart()
00463         format1 += '8s13f'
00464         format1 = bytes(format1)
00465         isMagnitudePhase = self.isMagnitudePhase()
00466 
00467         while len(self.data)>=64: # 16*4
00468             eData     = self.data[0:64]
00469             self.data = self.data[64: ]
00470             #print "len(data) = ",len(eData)
00471 
00472             out = unpack(format1, eData)
00473             (eid,eName,axr,ayr,azr,vxr,vyr,vzr,pressure,
00474                        axi,ayi,azi,vxi,vyi,vzi) = out
00475             eid2  = extract(eid,dt)
00476             eName = eName.strip()
00477             #print "eType=%s" %(eType)
00478             
00479             if isMagnitudePhase:
00480                 ax = polarToRealImag(axr,axi); vx = polarToRealImag(vxr,vxi)
00481                 ay = polarToRealImag(ayr,ayi); vy = polarToRealImag(vyr,vyi)
00482                 az = polarToRealImag(azr,azi); vz = polarToRealImag(vzr,vzi)
00483             else:
00484                 ax = complex(axr,axi); vx = complex(vxr,vxi)
00485                 ay = complex(ayr,ayi); vy = complex(vyr,vyi)
00486                 az = complex(azr,azi); vz = complex(vzr,vzi)
00487 
00488             dataIn = [eid2,eName,ax,ay,az,vx,vy,vz,pressure]
00489             #print "%s" %(self.ElementType(self.elementType)),dataIn
00490             #eid = self.obj.addNewEid(out)
00491             self.obj.add(dt,dataIn)
00492             #print "len(data) = ",len(self.data)
00493         ###
00494         #print self.bendForces
00495 
00496     def OEF_CBush_alt(self): # 102-CBUSH
00497         dt = self.nonlinearFactor
00498         (format1,extract) = self.getOEF_FormatStart()
00499         format1 += '12f'
00500         format1 = bytes(format1)
00501         isMagnitudePhase = self.isMagnitudePhase()
00502 
00503         while len(self.data)>=52: # 13*4
00504             eData     = self.data[0:52]
00505             self.data = self.data[52: ]
00506             #print "len(data) = ",len(eData)
00507 
00508             out = unpack(format1, eData)
00509             (eid,fxr,fyr,fzr,mxr,myr,mzr,
00510                  fxi,fyi,fzi,mxi,myi,mzi) = out
00511             eid2  = extract(eid,dt)
00512             #print "eType=%s" %(eType)
00513             
00514             if isMagnitudePhase:
00515                 fx = polarToRealImag(fxr,fxi); mx = polarToRealImag(mxr,mxi)
00516                 fy = polarToRealImag(fyr,fyi); my = polarToRealImag(myr,myi)
00517                 fz = polarToRealImag(fzr,fzi); mz = polarToRealImag(mzr,mzi)
00518             else:
00519                 fx = complex(fxr,fxi); mx = complex(mxr,mxi)
00520                 fy = complex(fyr,fyi); my = complex(myr,myi)
00521                 fz = complex(fzr,fzi); mz = complex(mzr,mzi)
00522 
00523             dataIn = [eid2,fx,fy,fz,mx,my,mz]
00524             #print "%s" %(self.ElementType(self.elementType)),dataIn
00525             #eid = self.obj.addNewEid(out)
00526             self.obj.add(dt,dataIn)
00527             #print "len(data) = ",len(self.data)
00528         ###
00529         #print self.bushForces
00530 
00531     def OEF_Force_VU_alt(self): # 191-VUBEAM
00532         dt = self.nonlinearFactor
00533         (format1,extract) = self.getOEF_FormatStart()
00534         format1 += '2i4s'
00535         format1 = bytes(format1)
00536         isMagnitudePhase = self.isMagnitudePhase()
00537 
00538         if self.elementType in [191]:
00539             nNodes = 2
00540         else:
00541             raise NotImplementedError(self.codeInformation())
00542 
00543         formatAll = 'i13f'
00544         formatAll = bytes(formatAll)
00545         n = 16+56*nNodes
00546         while len(self.data)>=n:
00547             eData     = self.data[0:16] # 8*4
00548             self.data = self.data[16: ]
00549             #print "len(data) = ",len(eData)
00550 
00551             out = unpack(format1, eData)
00552             (eid,parent,coord,icord) = out
00553 
00554             eid2  = extract(eid,dt)
00555             dataIn = [eid2,parent,coord,icord]
00556 
00557             forces = []
00558             for i in xrange(nNodes):
00559                 eData     = self.data[0:56] # 14*4
00560                 self.data = self.data[56: ]
00561                 #print "i=%s len(data)=%s" %(i,len(eData))
00562                 out = unpack(formatAll, eData)
00563                 [vugrid,posit,forceXr,shearYr,shearZr,torsionr,bendingYr,bendingZr,
00564                               forceXi,shearYi,shearZi,torsioni,bendingYi,bendingZi] = out
00565 
00566                 if isMagnitudePhase:
00567                     forceX   = polarToRealImag(forceXr,forceXi)
00568                     shearY   = polarToRealImag(shearYr,shearYi)
00569                     shearZ   = polarToRealImag(shearZr,shearZi)
00570                     torsion  = polarToRealImag(torsionr,torsioni)
00571                     bendingY = polarToRealImag(bendingYr,bendingYi)
00572                     bendingZ = polarToRealImag(bendingZr,bendingZi)
00573                 else:
00574                     forceX   = complex(forceXr,forceXi)
00575                     shearY   = complex(shearYr,shearYi)
00576                     shearZ   = complex(shearZr,shearZi)
00577                     torsion  = complex(torsionr,torsioni)
00578                     bendingY = complex(bendingYr,bendingYi)
00579                     bendingZ = complex(bendingZr,bendingZi)
00580 
00581                 out2 = [vugrid,posit,forceX,shearY,shearZ,torsion,bendingY,bendingZ]
00582                 forces.append(out2)
00583             dataIn.append(forces)
00584             #eType = a+b+c+d+e+f+g+h
00585             #print "eType=%s" %(eType)
00586             
00587             #dataIn = [vugrid,posit,forceX,shearY,shearZ,torsion,bendY,bendZ]
00588             #print "force %s" %(self.ElementType(self.elementType)),dataIn
00589             #eid = self.obj.addNewEid(out)
00590             self.obj.add(nNodes,dt,dataIn)
00591             #print "len(data) = ",len(self.data)
00592         ###
00593         if self.makeOp2Debug:
00594             print("done with OEF_Force_VU")
00595         #print(self.force_VU)
00596 
00597     def OEF_Force_VUTRIA_alt(self): # 189-VUQUAD,190-VUTRIA
00598         dt = self.nonlinearFactor
00599         (format1,extract) = self.getOEF_FormatStart()
00600         format1 += 'ii4sii'
00601         format1 = bytes(format1)
00602         isMagnitudePhase = self.isMagnitudePhase()
00603 
00604         if self.elementType in [189]: # VUQUAD
00605             nNodes = 4
00606         elif self.elementType in [190]: # VUTRIA
00607             nNodes = 3
00608         else:
00609             raise NotImplementedError(self.codeInformation())
00610 
00611         formatAll = 'i3f3i5fi3f3i5fi'
00612         format1 = bytes(format1)
00613         formatAll = bytes(formatAll)
00614         n = 24+100*nNodes
00615         while len(self.data)>=n:
00616             eData     = self.data[0:24] # 6*4
00617             self.data = self.data[24: ]
00618             #print "len(data) = ",len(eData)
00619 
00620             out = unpack(format1, eData)
00621             (eid,parent,coord,icord,theta,_) = out
00622 
00623             eid2  = extract(eid,dt)
00624             dataIn = [eid2,parent,coord,icord,theta]
00625 
00626             forces = []
00627             for i in xrange(nNodes):
00628                 eData     = self.data[0:100] # 13*4
00629                 self.data = self.data[100: ]
00630                 #print "i=%s len(data)=%s" %(i,len(eData))
00631                 out = unpack(formatAll, eData)
00632                 [vugrid,mfxr,mfyr,mfxyr,a,b,c,bmxr,bmyr,bmxyr,syzr,szxr,d,
00633                         mfxi,mfyi,mfxyi,a,b,c,bmxi,bmyi,bmxyi,syzi,szxi,d] = out
00634 
00635                 if isMagnitudePhase:
00636                     mfx  = polarToRealImag(mfxr,mfxi)
00637                     mfy  = polarToRealImag(mfyr,mfyi)
00638                     mfxy = polarToRealImag(mfxyr,mfxyi)
00639                     bmx  = polarToRealImag(bmxr,bmxi)
00640                     bmy  = polarToRealImag(bmyr,bmyi)
00641                     bmxy = polarToRealImag(bmxyr,bmxyi)
00642                     syz  = polarToRealImag(syzr,syzi)
00643                     szx  = polarToRealImag(szxr,szxi)
00644                 else:
00645                     mfx  = complex(mfxr,mfxi)
00646                     mfy  = complex(mfyr,mfyi)
00647                     mfxy = complex(mfxyr,mfxyi)
00648                     bmx  = complex(bmxr,bmxi)
00649                     bmy  = complex(bmyr,bmyi)
00650                     bmxy = complex(bmxyr,bmxyi)
00651                     syz  = complex(syzr,syzi)
00652                     szx  = complex(szxr,szxi)
00653 
00654                 out2 = [vugrid,mfx,mfy,mfxy,bmx,bmy,bmxy,syz,szx]
00655                 forces.append(out2)
00656             ###
00657             dataIn.append(forces)
00658             #print "eType=%s" %(eType)
00659             
00660             #dataIn = [vugrid,mfxr,mfyr,mfxyr,bmxr,bmyr,bmxyr,syzr,szxr,
00661                              #mfxi,mfyi,mfxyi,bmxi,bmyi,bmxyi,syzi,szxi]
00662             #print "force %s" %(self.ElementType(self.elementType)),dataIn
00663             #eid = self.obj.addNewEid(out)
00664             self.obj.add(nNodes,dt,dataIn)
00665             #print "len(data) = ",len(self.data)
00666         ###
00667         if self.makeOp2Debug:
00668             print("done with OEF_Force_VUTRIA")
00669         #print(self.force_VU_2D)
 All Classes Namespaces Files Functions Variables