pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
elementsStressStrain.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 #91  -> PENTANL
00033 #2   -> BEAM
00034 #33  -> TUBE
00035 #92  -> CONRODNL
00036 class ComplexElementsStressStrain(object):
00037 
00038     def OES_Rod1_alt(self):
00039         """
00040         genericStressReader - works on CROD_1, CELAS2_12
00041         stress & strain
00042         formatCode=1 sortCode=1 (eid,axial,axial,torsion,torsion)
00043         """
00044         dt = self.nonlinearFactor
00045         (format1,extract) = self.getOUG_FormatStart()
00046         nTotal = 12
00047         format1 += '4f'
00048         format1 = bytes(format1)
00049         isMagnitudePhase = self.isMagnitudePhase()
00050         
00051         n = 0
00052         nEntries = len(self.data)//nTotal
00053         for i in xrange(nEntries):
00054             eData = self.data[n:n+nTotal]
00055             (eid,axialReal,axialImag,torsionReal,torsionImag)= unpack(format1,eData)
00056 
00057             if isMagnitudePhase:
00058                 (axial)   = polarToRealImag(axialReal,axialImag)
00059                 (torsion) = polarToRealImag(torsionReal,torsionImag)
00060             else:
00061                 axial   = complex(axialReal,axialImag)
00062                 torsion = complex(torsionReal,torsionImag)
00063             
00064             #print "out = ",out
00065             eid = extract(eid,dt)
00066             self.obj.addNewEid(dt,eid,axial,torsion)
00067             n+=nTotal
00068         ###
00069         self.data = self.data[n: ]
00070 
00071     def OES_Elas1_alt(self):
00072         """
00073         genericStressReader - works on CROD_1, CELAS2_12
00074         stress & strain
00075         formatCode=1 sortCode=1 (eid,axial,axial,torsion,torsion)
00076         """
00077         dt = self.nonlinearFactor
00078         (format1,extract) = self.getOUG_FormatStart()
00079         nTotal = 12
00080         format1 += '2f'
00081         format1 = bytes(format1)
00082         isMagnitudePhase = self.isMagnitudePhase()
00083         
00084         n = 0
00085         nEntries = len(self.data)//nTotal
00086         for i in xrange(nEntries):
00087             eData = self.data[n:n+nTotal]
00088             (eid,axialReal,axialImag) = unpack(format1,eData)
00089 
00090             if isMagnitudePhase:
00091                 axial = polarToRealImag(axialReal,axialImag)
00092             else:
00093                 axial = complex(axialReal,axialImag)
00094             
00095             #print "out = ",out
00096             eid = extract(eid,dt)
00097             self.obj.addNewEid(dt,eid,axial)
00098             n+=nTotal
00099         ###
00100         self.data = self.data[n: ]
00101 
00102 
00103     def OES_CBAR_34_alt(self):
00104         dt = self.nonlinearFactor
00105         #print "len(data) = ",len(self.data)
00106         assert self.numWide==19,'invalid numWide...numWide=%s' %(self.numWide)
00107 
00108         (format1,extract) = self.getOUG_FormatStart()
00109         format1 += '18f'
00110         format1 = bytes(format1)
00111         isMagnitudePhase = self.isMagnitudePhase()
00112 
00113         while len(self.data)>=76:
00114             #self.printBlock(self.data)
00115             eData     = self.data[0:76]
00116             self.data = self.data[76: ]
00117             #print "len(data) = ",len(eData)
00118 
00119             (eid,s1ar,s2ar,s3ar,s4ar,axialr,
00120                  s1ai,s2ai,s3ai,s4ai,axiali,
00121                  s1br,s2br,s3br,s4br,      
00122                  s1bi,s2bi,s3bi,s4bi )= unpack(format1,eData)
00123 
00124             if isMagnitudePhase:
00125                 s1a = polarToRealImag(s1ar,s1ai); s1b = polarToRealImag(s1br,s1bi)
00126                 s2a = polarToRealImag(s2ar,s2ai); s2b = polarToRealImag(s2br,s2bi)
00127                 s3a = polarToRealImag(s3ar,s3ai); s3b = polarToRealImag(s3br,s3bi)
00128                 s4a = polarToRealImag(s4ar,s4ai); s4b = polarToRealImag(s4br,s4bi)
00129                 axial = polarToRealImag(axialr,axiali)
00130 
00131             else:
00132                 s1a = complex(s1ar,s1ai); s1b = complex(s1br,s1bi)
00133                 s2a = complex(s2ar,s2ai); s2b = complex(s2br,s2bi)
00134                 s3a = complex(s3ar,s3ai); s3b = complex(s3br,s3bi)
00135                 s4a = complex(s4ar,s4ai); s4b = complex(s4br,s4bi)
00136                 axial = complex(axialr,axiali)
00137 
00138             eid2 = extract(eid,dt)
00139             self.obj.addNewEid('CBAR',dt,eid2,s1a,s2a,s3a,s4a,axial,
00140                                               s1b,s2b,s3b,s4b      )
00141 
00142             #print "eid=%i s1=%i s2=%i s3=%i s4=%i axial=%-5i" %(eid,s1a,s2a,s3a,s4a,axial)
00143             #print "         s1=%i s2=%i s3=%i s4=%i"          %(s1b,s2b,s3b,s4b)
00144             #print "len(data) = ",len(self.data)
00145         ###
00146 
00147     def OES_CQUAD4_33_alt(self):
00148         """
00149         GRID-ID  DISTANCE,NORMAL-X,NORMAL-Y,SHEAR-XY
00150         """
00151         dt = self.nonlinearFactor
00152         (format1,extract) = self.getOUG_FormatStart()
00153         format1 += '14f'
00154         format1 = bytes(format1)
00155         isMagnitudePhase = self.isMagnitudePhase()
00156         
00157         nNodes = 0 # centroid + 4 corner points
00158         #self.printSection(20)
00159         #term = data[0:4] CEN/
00160         #data = data[4:]
00161         #print "*****"
00162         #self.printBlock(self.data)
00163         #print "self.numWide = ",self.numWide
00164         #print "len(data) = ",len(self.data)
00165         
00166         assert self.numWide == 15,'invalid numWide...numWide=%s' %(self.numWide)
00167         while len(self.data) >= 60: # 2+15*5 = 77 -> 77*4 = 308
00168             #print self.printBlock(self.data[0:100])
00169             #(eid,) = unpack(b'i',self.data[0:4])
00170             #print "abcd=",abcd
00171             #self.data = self.data[8:]  # 2
00172             eData     = self.data[0:60]  # 4*15=60
00173             self.data = self.data[60: ]
00174             out = unpack(format1, eData)  # 15
00175             if self.makeOp2Debug:
00176                 self.op2Debug.write('%s\n' %(str(out)))
00177             (eid,fd1,sx1r,sx1i,sy1r,sy1i,txy1r,txy1i,
00178                  fd2,sx2r,sx2i,sy2r,sy2i,txy2r,txy2i) = out
00179 
00180             if isMagnitudePhase:
00181                 sx1  = polarToRealImag(sx1r,sx1i);   sx2  = polarToRealImag(sx2r,sx2i)
00182                 sy1  = polarToRealImag(sy1r,sy1i);   sy2  = polarToRealImag(sy2r,sy2i)
00183                 txy1 = polarToRealImag(txy1r,txy1i); txy2 = polarToRealImag(txy2r,txy2i)
00184             else:
00185                 sx1  = complex(sx1r,sx1i);   sx2  = complex(sx2r,sx2i)
00186                 sy1  = complex(sy1r,sy1i);   sy2  = complex(sy2r,sy2i)
00187                 txy1 = complex(txy1r,txy1i); txy2 = complex(txy2r,txy2i)
00188 
00189             eid = extract(eid,dt)
00190 
00191             #print "eid=%i grid=%s fd1=%-3.1f sx1=%s sy1=%s txy1=%s" %(eid,'C',fd1,sx1,sy1,txy1)
00192             #print   "             fd2=%-3.1f sx2=%s sy2=%s txy2=%s\n"       %(fd2,sx2,sy2,txy2)
00193             #print "nNodes = ",nNodes
00194             self.obj.addNewEid('CQUAD4',dt,eid,'C',fd1,sx1,sy1,txy1)
00195             self.obj.add(               dt,eid,'C',fd2,sx2,sy2,txy2)
00196             
00197             for nodeID in xrange(nNodes):   #nodes pts
00198                 eData     = self.data[0:60] # 4*15=60
00199                 self.data = self.data[60: ]
00200                 out = unpack(b'i14f',eData[0:60])
00201                 if self.makeOp2Debug:
00202                     self.op2Debug.write('%s\n' %(str(out)))
00203                 (grid,fd1,sx1r,sx1i,sy1r,sy1i,txy1r,txy1i,
00204                       fd2,sx2r,sx2i,sy2r,sy2i,txy2r,txy2i) = out
00205 
00206                 if isMagnitudePhase:
00207                     sx1  = polarToRealImag(sx1r,sx1i);   sx2  = polarToRealImag(sx2r,sx2i)
00208                     sy1  = polarToRealImag(sy1r,sy1i);   sy2  = polarToRealImag(sy2r,sy2i)
00209                     txy1 = polarToRealImag(txy1r,txy1i); txy2 = polarToRealImag(txy2r,txy2i)
00210                 else:
00211                     sx1  = complex(sx1r,sx1i);   sx2  = complex(sx2r,sx2i)
00212                     sy1  = complex(sy1r,sy1i);   sy2  = complex(sy2r,sy2i)
00213                     txy1 = complex(txy1r,txy1i); txy2 = complex(txy2r,txy2i)
00214 
00215                 #print "eid=%i grid=%i fd1=%i sx1=%i sy1=%i txy1=%i\n" %(eid,grid,fd1,sx1,sy1,txy1)
00216                 #print "               fd2=%i sx2=%i sy2=%i txy2=%i\n"          %(fd2,sx2,sy2,txy2)
00217                 #print "len(data) = ",len(self.data)
00218                 #self.printBlock(self.data)
00219                 self.obj.addNewNode(dt,eid,grid,fd1,sx1,sy1,txy1)
00220                 self.obj.add(       dt,eid,grid,fd2,sx2,sy2,txy2)
00221             ###
00222             #print '--------------------'
00223             #print "len(data) = ",len(self.data)
00224             #print "tell = ",self.op2.tell()
00225             
00226             #self.printSection(100)
00227             #self.dn += 348
00228         ###
00229 
00230     def OES_CQUAD4NL_90_alt(self):
00231         dt = self.nonlinearFactor
00232         (format1,extract) = self.getOUG_FormatStart()
00233         
00234         assert self.numWide==25,"numWide=%s not 25" %(self.numWide)
00235         nTotal = 100 #4*25
00236         format1 += '24f'
00237         format1 = bytes(format1)
00238 
00239         while len(self.data)>=nTotal:
00240             eData     = self.data[0:nTotal]
00241             self.data = self.data[nTotal: ]
00242 
00243             out = unpack(format1,eData) # numWide=25
00244             (eid,fd1,sx1,sy1,xxx,txy1,es1,eps1,ecs1,ex1,ey1,xxx,exy1,
00245                  fd2,sx2,sy2,xxx,txy2,es2,eps2,ecs2,ex2,ey2,xxx,exy2) = out
00246             eid = extract(eid,dt)
00247 
00248             data = (eid,fd1,sx1,sy1,xxx,txy1,es1,eps1,ecs1,ex1,ey1,xxx,exy1)
00249             self.obj.addNewEid(self.elementType,dt,data)
00250             data = (eid,fd2,sx2,sy2,xxx,txy2,es2,eps2,ecs2,ex2,ey2,xxx,exy2)
00251             self.obj.add(dt,data)
00252             
00253             #print "eid=%s axial=%s equivStress=%s totalStrain=%s effPlasticCreepStrain=%s effCreepStrain=%s linearTorsionalStresss=%s" %(eid,axial,equivStress,totalStrain,effPlasticCreepStrain,effCreepStrain,linearTorsionalStresss)
00254             
00255             if self.makeOp2Debug:
00256                 self.op2Debug.write('%s\n' %(str(out)))
00257         ###
00258     
00259     def OES_CQUAD4_144_alt(self):
00260         """
00261         GRID-ID  DISTANCE,NORMAL-X,NORMAL-Y,SHEAR-XY,ANGLE,MAJOR MINOR,VONMISES
00262         """
00263         if self.makeOp2Debug:
00264             self.op2Debug.write('---CQUAD4_144---\n')
00265 
00266         #self.printSection(20)
00267         #term = data[0:4] CEN/
00268         #data = data[4:]
00269         #print "*****"
00270         #self.printBlock(self.data)
00271         #assert self.numWide==87,'invalid numWide...numWide=%s' %(self.numWide)
00272         #if self.numWide==87: # 2+(17-1)*5 = 87 -> 87*4 = 348
00273         
00274         if self.elementType==144: # CQUAD4
00275             nTotal = 308  # 2+15*5 = 77 -> 87*4 = 308
00276             nNodes = 4    # centroid + 4 corner points
00277             eType  = 'CQUAD4'
00278         elif self.elementType==64: # CQUAD8 - done
00279             nTotal = 308  # 2+15*5 = 77 -> 77*4 = 308
00280             nNodes = 4    # centroid + 4 corner points
00281             eType  = 'CQUAD8'
00282         elif self.elementType==82: # CQUADR
00283             nTotal = 308  # 2+15*5 = 77 -> 87*4 = 308
00284             nNodes = 4    # centroid + 4 corner points
00285             eType  = 'CQUAD4' ## @todo write the word CQUADR
00286 
00287         elif self.elementType==75: # CTRIA6
00288             nTotal = 248  # 2+15*3 = 62 -> 62*4 = 248
00289             nNodes = 3    # centroid + 3 corner points
00290             eType  = 'CTRIA6'
00291         elif self.elementType==70: # CTRIAR
00292             nTotal = 248  # 2+15*4 = 62 -> 62*4 = 248
00293             nNodes = 3    # centroid + 3 corner points
00294             eType  = 'CTRIAR' ## @todo write the word CTRIAR
00295         else:
00296             raise Exception('elementType=%s nTotal not defined...' %(self.elementType))
00297         
00298         assert nTotal==self.numWide*4,'eType=%s numWide*4=%s not nTotal=%s' %(self.elementType,self.numWide*4,nTotal)
00299         dt = self.nonlinearFactor
00300         (format1,extract) = self.getOUG_FormatStart()
00301         format1 += '14f'
00302         format1 = bytes(format1)
00303         isMagnitudePhase = self.isMagnitudePhase()
00304 
00305         while len(self.data) >= nTotal:
00306             (eid, _) = unpack(b'i4s',self.data[0:8])
00307             self.data = self.data[8:]  # 2
00308             eid = extract(eid,dt)
00309             eData     = self.data[0:60] # 4*15
00310             self.data = self.data[60: ]
00311             out = unpack(format1,eData)  # len=15*4
00312             if self.makeOp2Debug:
00313                 self.op2Debug.write('%s\n' %(str(out)))
00314             (grid,fd1,sx1r,sx1i,sy1r,sy1i,txy1r,txy1i,
00315                   fd2,sx2r,sx2i,sy2r,sy2i,txy2r,txy2i) = out
00316             grid = 'C'
00317 
00318             if isMagnitudePhase:
00319                 sx1  = polarToRealImag(sx1r,sx1i);   sy1  = polarToRealImag(sy1r,sy1i)
00320                 sx2  = polarToRealImag(sx2r,sx2i);   sy2  = polarToRealImag(sy2r,sy2i)
00321                 txy1 = polarToRealImag(txy1r,txy1i); txy2 = polarToRealImag(txy2r,txy2i)
00322             else:
00323                 sx1  = complex(sx1r,sx1i);   sy1  = complex(sy1r,sy1i)
00324                 sx2  = complex(sx2r,sx2i);   sy2  = complex(sy2r,sy2i)
00325                 txy1 = complex(txy1r,txy1i); txy2 = complex(txy2r,txy2i)
00326 
00327             self.obj.addNewEid(eType,dt,eid,grid,fd1,sx1,sy1,txy1)
00328             self.obj.add(            dt,eid,grid,fd2,sx2,sy2,txy2)
00329 
00330             for nodeID in xrange(nNodes):   #nodes pts
00331                 eData     = self.data[0:60] # 4*15=60
00332                 self.data = self.data[60: ]
00333                 out = unpack(b'i14f',eData)
00334                 if self.makeOp2Debug:
00335                     self.op2Debug.write('%s\n' %(str(out)))
00336                 (grid,fd1,sx1r,sx1i,sy1r,sy1i,txy1r,txy1i,
00337                       fd2,sx2r,sx2i,sy2r,sy2i,txy2r,txy2i) = out
00338 
00339                 if isMagnitudePhase:
00340                     sx1  = polarToRealImag(sx1r,sx1i);   sx2  = polarToRealImag(sx2r,sx2i)
00341                     sy1  = polarToRealImag(sy1r,sy1i);   sy2  = polarToRealImag(sy2r,sy2i)
00342                     txy1 = polarToRealImag(txy1r,txy1i); txy2 = polarToRealImag(txy2r,txy2i)
00343                 else:
00344                     sx1  = complex(sx1r,sx1i);   sx2  = complex(sx2r,sx2i)
00345                     sy1  = complex(sy1r,sy1i);   sy2  = complex(sy2r,sy2i)
00346                     txy1 = complex(txy1r,txy1i); txy2 = complex(txy2r,txy2i)
00347 
00348                 #print "eid=%i grid=%i fd1=%i sx1=%i sy1=%i txy1=%i"   %(eid,grid,fd1,sx1,sy1,txy1)
00349                 #print "               fd2=%i sx2=%i sy2=%i txy2=%i\n"          %(fd2,sx2,sy2,txy2)
00350                 #print "len(data) = ",len(self.data)
00351                 #self.printBlock(self.data)
00352                 self.obj.addNewNode(dt,eid,grid,fd1,sx1,sy1,txy1)
00353                 self.obj.add(       dt,eid,grid,fd2,sx2,sy2,txy2)
00354             ###
00355             #print '--------------------'
00356             #print "len(data) = ",len(self.data)
00357             #self.dn += 348
00358         ###
00359 
00360 
00361     def OES_CTRIA3_74_alt(self): # in progress
00362         """
00363         DISTANCE,NORMAL-X,NORMAL-Y,SHEAR-XY,ANGLE,MAJOR,MINOR,VONMISES
00364         stress is extracted at the centroid
00365         """
00366         assert self.numWide==15,'invalid numWide...numWide=%s' %(self.numWide)
00367 
00368         dt = self.nonlinearFactor
00369         (format1,extract) = self.getOUG_FormatStart()
00370         format1 += '14f'
00371         format1 = bytes(format1)
00372         isMagnitudePhase = self.isMagnitudePhase()
00373 
00374         while len(self.data)>=60:
00375             eData     = self.data[0:60] # 4*15=60
00376             self.data = self.data[60: ]
00377             out = unpack(format1,eData)
00378 
00379             (eid,fd1,sx1r,sx1i,sy1r,sy1i,txy1r,txy1i,
00380                  fd2,sx2r,sx2i,sy2r,sy2i,txy2r,txy2i) = out
00381 
00382             if isMagnitudePhase:
00383                 sx1  = polarToRealImag(sx1r,sx1i);   sy1  = polarToRealImag(sy1r,sy1i)
00384                 sx2  = polarToRealImag(sx2r,sx2i);   sy2  = polarToRealImag(sy2r,sy2i)
00385                 txy1 = polarToRealImag(txy1r,txy1i); txy2 = polarToRealImag(txy2r,txy2i)
00386             else:
00387                 sx1  = complex(sx1r,sx1i);   sy1  = complex(sy1r,sy1i)
00388                 sx2  = complex(sx2r,sx2i);   sy2  = complex(sy2r,sy2i)
00389                 txy1 = complex(txy1r,txy1i); txy2 = complex(txy2r,txy2i)
00390 
00391             eid = extract(eid,dt)
00392             #print "eid=%i fd1=%i sx1=%i sy1=%i txy1=%i" %(eid,fd1,sx1,sy1,txy1)
00393             #print  "      fd2=%i sx2=%i sy2=%i txy2=%i\n"   %(fd2,sx2,sy2,txy2)
00394             self.obj.addNewEid('CTRIA3',dt,eid,'C',fd1,sx1,sy1,txy1)
00395             self.obj.add(               dt,eid,'C',fd2,sx2,sy2,txy2)
00396             if self.makeOp2Debug:
00397                 self.op2Debug.write('%s\n' %(str(out)))
00398         ###
00399 
00400 
00401 
00402 
00403 
00404 #==============================================================================
00405 # dont work...
00406 
00407     def xOES_CBEAM_2_alt(self):
00408         raise NotImplementedError()
00409         dt = self.nonlinearFactor
00410         (formatStart,extract) = self.getOUG_FormatStart()
00411 
00412         nNodes = 10 # 11-1
00413         nTotal       = self.obj.getLengthTotal()
00414         (n1,format1) = self.obj.getLength1()
00415         (n2,format2) = self.obj.getLength2()
00416         format1 = formatStart+format1
00417         format1 = bytes(format1)
00418         format2 = bytes(format2)
00419 
00420         while len(self.data)>=nTotal:
00421             eData     = self.data[0:n1]
00422             self.data = self.data[n1: ]
00423             #print "len(data) = ",len(eData)
00424 
00425             out = unpack(format1, eData)
00426             #print "outA = ",out
00427             eid2 = extract(out[0],dt)
00428             self.obj.addNewEid(dt,eid2,out[1:])
00429             
00430             for iNode in xrange(nNodes):
00431                 eData     = self.data[0:n2]
00432                 self.data = self.data[n2: ]
00433                 out = unpack(format2, eData)
00434                 #print "outB = ",out
00435                 self.obj.add(dt,eid2,out)
00436 
00437             #print "eid=%i axial=%i torsion=%i" %(eid,axial,torsion)
00438             #print "len(data) = ",len(self.data)
00439         ###
00440 
00441     def xOES_CSOLID_67_alt(self):  # works
00442         """
00443         stress is extracted at the centroid
00444         CTETRA_39
00445         CPENTA_67
00446         CHEXA_68
00447         """
00448         raise NotImplementedError()
00449         dt = self.nonlinearFactor
00450         (format1,extract) = self.getOUG_FormatStart()
00451         format1 += "i4si"
00452         format1 = bytes(format1)
00453 
00454         #nNodes = 5 # 1 centroid + 4 corner points
00455         #self.printSection(20)
00456         #term      = self.data[0:4] CEN/
00457         #self.data = self.data[4:]
00458         #print "*****"
00459         ElementType = self.ElementType(self.elementType)
00460         nNodes=1  # this is a minimum, it will be reset later
00461         nNodesExpected = 1
00462         #assert self.numWide in [109,151,193],'invalid numWide...numWide=%s' %(self.numWide)
00463         while len(self.data)>= 16+84*nNodesExpected:
00464             eData     = self.data[0:16]
00465             self.data = self.data[16:]
00466             #self.printBlock(eData)
00467 
00468             out = unpack(format1,eData)
00469             (eid, cid, abcd, nNodes) = out
00470             eid2 = extract(eid,dt)
00471             if self.makeOp2Debug:
00472                 self.op2Debug.write('%s\n' %(str(out)))
00473             #print "abcd = |%s|" %(abcd)
00474             #print "eid=%s cid=%s nNodes=%s nNodesExpected=%s" %(eid,cid,nNodes,nNodesExpected)
00475             
00476             assert nNodes < 21,self.printBlock(eData)
00477 
00478             if   ElementType=='TETRA':   nNodesExpected = 5
00479             elif ElementType=='PENTA':   nNodesExpected = 7
00480             elif ElementType=='HEXA':    nNodesExpected = 9
00481             else:
00482                 raise NotImplementedError('not supported....EType=%s eType=%s nNodes=%s numWide=%s' %(ElementType,self.elementType,nNodes,self.numWide))
00483 
00484             #print "len(data) = ",len(self.data)
00485             for nodeID in xrange(nNodesExpected):   #nodes pts, +1 for centroid (???)
00486                 #print "len(data)A = ",len(self.data)
00487                 eData     = self.data[0:84] # 4*21=84 # for the stresses
00488                 self.data = self.data[84: ]
00489                 #print "len(data)B = ",len(self.data)
00490                 #self.printBlock(eData)
00491 
00492                 #print "self.tableCode = ",self.tableCode
00493                 #print "len(data) = ",len(self.data)
00494                 
00495                 gridDevice, = unpack(b'i',eData[0:4])
00496                 #print "gridDevice = ",gridDevice
00497                 if gridDevice==0:
00498                     grid = 'C'
00499                 else:
00500                     #grid = (gridDevice - deviceCode) // 10
00501                     grid = gridDevice
00502                 ###
00503 
00504                 out = unpack(b'ffffffffffffffffffff',eData[4:84])
00505                 if self.makeOp2Debug:
00506                     self.op2Debug.write('%s\n' %(str(out)))
00507                 (sxx,sxy,s1,a1,a2,a3,pressure,svm,
00508                  syy,syz,s2,b1,b2,b3,
00509                  szz,sxz,s3,c1,c2,c3) = out
00510                 
00511                 #print "%s eid=%s cid=%s grid=%s sxx=%-6i txy=%-5i s1=%-6i a1=%i a2=%i a3=%i press=%i vm=%s" %(elementType,eid,cid,grid,sxx,sxy,s1,a1,a2,a3,pressure,svm)
00512                 #print "%s eid=%s cid=%s grid=%s syy=%-6i tyz=%-5i s2=%-6i b1=%i b2=%i b3=%i"                %(elementType,eid,cid,grid,syy,syz,s2,b1,b2,b3)
00513                 #print "%s eid=%s cid=%s grid=%s szz=%-6i txz=%-5i s3=%-6i c1=%i c2=%i c3=%i"                %(elementType,eid,cid,grid,szz,sxz,s3,c1,c2,c3)
00514                 #print ""
00515 
00516                 #smax = max(s1,s2,s3)
00517                 #smin = min(s1,s2,s3)
00518                 
00519                 aCos = []
00520                 bCos = []
00521                 cCos = []
00522                 if nodeID==0:
00523                     #print "adding new eid"
00524                     self.obj.addNewEid(ElementType,cid,dt,eid2,grid,sxx,syy,szz,sxy,syz,sxz,s1,s2,s3,aCos,bCos,cCos,pressure,svm)
00525                 else:
00526                     self.obj.add(                      dt,eid2,grid,sxx,syy,szz,sxy,syz,sxz,s1,s2,s3,aCos,bCos,cCos,pressure,svm)
00527                 #print "eid=%i grid=%i fd1=%i sx1=%i sy1=%i txy1=%i angle1=%i major1=%i minor1=%i vm1=%i" %(eid,grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00528                 #print "               fd2=%i sx2=%i sy2=%i txy2=%i angle2=%i major2=%i minor2=%i vm2=%i\n"          %(fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00529                 #self.printBlock(data)
00530             #sys.exit('finished a CEHXA')
00531             #print self.solidStress[self.iSubcase]
00532             ###
00533             #print '--------------------'
00534             #print "len(data) = ",len(self.data)
00535             
00536             #self.printSection(100)
00537             #self.printBlock(self.data[0:100])
00538             #self.printBlock(self.data[1:100])
00539             #self.printBlock(self.data[2:100])
00540             #self.printBlock(self.data[3:100])
00541         ###
00542         #print self.solidStress[self.iSubcase]
00543 
00544     def xOES_CSOLID_85_alt(self):  # works
00545         """
00546         stress is extracted at the centroid
00547         CTETRA_85
00548         CPENTA_91 ???
00549         CHEXA_93  ???
00550         """
00551         raise NotImplementedError()
00552         #print "starting nonlinear solid element..."
00553         #nNodes = 5 # 1 centroid + 4 corner points
00554         #self.printSection(20)
00555         #term      = self.data[0:4] CEN/
00556         #self.data = self.data[4:]
00557         #print "*****"
00558         dt = self.nonlinearFactor
00559         (format1,extract) = self.getOUG_FormatStart()
00560         format1 += '4s'
00561         format1 = bytes(format1)
00562 
00563         nNodes=4  # this is a minimum, it will be reset later
00564         nNodesExpected = 1
00565         assert self.numWide in [82],'invalid numWide...numWide=%s' %(self.numWide)
00566         while len(self.data)>= 16+84*nNodesExpected:
00567             eData     = self.data[0:8]
00568             self.data = self.data[8:]
00569             #self.printBlock(eData)
00570 
00571             out = unpack(format1,eData)
00572             (eid, abcd) = out
00573             if self.makeOp2Debug:
00574                 self.op2Debug.write('%s\n' %(str(out)))
00575             #print "abcd = |%s|" %(abcd)
00576             #print "eid=%s cid=%s nNodes=%s nNodesExpected=%s" %(eid,cid,nNodes,nNodesExpected)
00577             
00578             assert nNodes < 21,self.printBlock(eData)
00579             eid = extract(eid,dt)
00580             if(  nNodes in [4,10]):
00581                 elementType = "CTETRA"
00582                 nNodesExpected = 5
00583             #elif(nNodes in [6,15]):
00584             #    elementType = "CPENTA"
00585             #    nNodesExpected = 7
00586             #elif(nNodes in [8,20]):
00587             #    elementType = "CHEXA"
00588             #    nNodesExpected = 9
00589             #else:
00590             #    raise Exception('not supported....nNodes=%s' %(nNodes))
00591 
00592             #print "len(data) = ",len(self.data)
00593             for nodeID in xrange(nNodesExpected):   #nodes pts, +1 for centroid (???)
00594                 #print "len(data)A = ",len(self.data)
00595                 eData     = self.data[0:64]  # 4*16=64 # for the stresses
00596                 self.data = self.data[64: ]
00597                 #print "len(data)B = ",len(self.data)
00598                 #self.printBlock(eData)
00599 
00600                 #print "self.tableCode = ",self.tableCode
00601                 
00602                 #print "len(data) = ",len(self.data)
00603                 
00604                 #gridDevice, = unpack(b'i',eData[0:4])
00605                 #print "gridDevice = ",gridDevice
00606 
00607                 out = unpack(b'ifffffffffffffff',eData[:64])  # 18-3 = 15
00608                 if self.makeOp2Debug:
00609                     self.op2Debug.write('%s\n' %(str(out)))
00610 
00611                 (gridGauss,sxx,syy,szz,sxy,syz,sxz,se,
00612                    eps,ecs,exx,eyy,ezz,exy,eyz,exz) = out
00613 
00614                 if gridGauss==0:
00615                     gridGauss = 'C'
00616                 else:
00617                     #grid = (gridDevice - deviceCode) // 10
00618                     gridGauss = gridGauss
00619                 ###
00620 
00621                 #print "%s gridGauss=%-5s eid=%s sxx=%g syy=%g szz=%g" %(elementType,gridGauss,eid,sxx,syy,szz)
00622                 
00623                 #print "%s eid=%s cid=%s grid=%s sxx=%-6i txy=%-5i s1=%-6i a1=%i a2=%i a3=%i press=%i vm=%s" %(elementType,eid,cid,grid,sxx,sxy,s1,a1,a2,a3,pressure,svm)
00624                 #print "%s eid=%s cid=%s grid=%s syy=%-6i tyz=%-5i s2=%-6i b1=%i b2=%i b3=%i"                %(elementType,eid,cid,grid,syy,syz,s2,b1,b2,b3)
00625                 #print "%s eid=%s cid=%s grid=%s szz=%-6i txz=%-5i s3=%-6i c1=%i c2=%i c3=%i"                %(elementType,eid,cid,grid,szz,sxz,s3,c1,c2,c3)
00626                 #print ""
00627 
00628                 #smax = max(s1,s2,s3)
00629                 #smin = min(s1,s2,s3)
00630                 
00631                 #if nodeID==0:
00632                 #    #print "adding new eid"
00633                 #    self.obj.addNewEid(elementType,cid,eid,grid,sxx,syy,szz,sxy,syz,sxz,aCos,bCos,cCos,pressure,svm)
00634                 #else:
00635                 #    self.obj.add(                      eid,grid,sxx,syy,szz,sxy,syz,sxz,aCos,bCos,cCos,pressure,svm)
00636                 #print "eid=%i grid=%i fd1=%i sx1=%i sy1=%i txy1=%i angle1=%i major1=%i minor1=%i vm1=%i" %(eid,grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00637                 #print "               fd2=%i sx2=%i sy2=%i txy2=%i angle2=%i major2=%i minor2=%i vm2=%i\n"          %(fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00638                 #self.printBlock(data)
00639             #sys.exit('finished a CTETRANL')
00640             #print self.solidStress[self.iSubcase]
00641             ###
00642             #print '--------------------'
00643             #print "len(data) = ",len(self.data)
00644             
00645             #self.printSection(100)
00646             #self.printBlock(self.data[0:100])
00647             #self.printBlock(self.data[1:100])
00648             #self.printBlock(self.data[2:100])
00649             #self.printBlock(self.data[3:100])
00650         ###
00651         #print self.solidStress[self.iSubcase]
00652 
00653 
00654     def xOES_CTRIAX6_53_alt(self):
00655         raise NotImplementedError()
00656         #(Format1,scaleValue) = self.OES_field1()
00657         #Format = Format1+'ifffffff'
00658         dt = self.nonlinearFactor
00659         (format1,extract) = self.getOUG_FormatStart()
00660         format1 += 'ifffffff'
00661         format1 = bytes(format1)
00662         while len(self.data)>=132: # (1+8*4) = 33*4 = 132
00663             eData     = self.data[0:36]  # 4*9=36
00664             self.data = self.data[36: ]
00665             out = unpack(format1,eData)
00666             (eid,loc,rs,azs,As,ss,maxp,tmax,octs) = out
00667             eid = extract(eid,dt)
00668             #print "eid=%s loc=%s rs=%s azs=%s as=%s ss=%s maxp=%s tmx=%s octs=%s" %(eid,loc,rs,azs,As,ss,maxp,tmax,octs)
00669             self.obj.addNewEid(dt,eid,loc,rs,azs,As,ss,maxp,tmax,octs)
00670 
00671             for i in xrange(3):
00672                 eData     = self.data[0:32]  #4*8-32
00673                 self.data = self.data[32: ]
00674                 out = unpack(b'ifffffff',eData)
00675                 (loc,rs,azs,As,ss,maxp,tmax,octs) = out
00676                 #print "eid=%s loc=%s rs=%s azs=%s as=%s ss=%s maxp=%s tmx=%s octs=%s" %(eid,loc,rs,azs,As,ss,maxp,tmax,octs)
00677                 self.obj.add(dt,eid,loc,rs,azs,As,ss,maxp,tmax,octs)
00678 
00679             if self.makeOp2Debug:
00680                 self.op2Debug.write('%s\n' %(str(out)))
00681         ###
00682 
00683     def xOES_RODNL_89_92_alt(self):
00684         raise NotImplementedError()
00685         dt = self.nonlinearFactor
00686         (format1,extract) = self.getOUG_FormatStart()
00687         format1 += 'ffffff'
00688         format1 = bytes(format1)
00689 
00690         while len(self.data)>=28:
00691             eData     = self.data[0:28] # 4*7=28
00692             self.data = self.data[28: ]
00693             out = unpack(format1,eData)
00694 
00695             (eid,axial,equivStress,totalStrain,effPlasticCreepStrain,effCreepStrain,linearTorsionalStresss) = out
00696             eid = extract(eid,dt)
00697             data = (eid,axial,equivStress,totalStrain,effPlasticCreepStrain,effCreepStrain,linearTorsionalStresss)
00698             
00699             #print "eid=%s axial=%s equivStress=%s totalStrain=%s effPlasticCreepStrain=%s effCreepStrain=%s linearTorsionalStresss=%s" %(eid,axial,equivStress,totalStrain,effPlasticCreepStrain,effCreepStrain,linearTorsionalStresss)
00700             #print "eid=%i fd1=%i sx1=%i sy1=%i txy1=%i angle1=%i major1=%i minor1=%i vm1=%i" %(eid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00701             #print  "      fd2=%i sx2=%i sy2=%i txy2=%i angle2=%i major2=%i minor2=%i vm2=%i\n"   %(fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00702             #self.obj.addNewEid('CTRIA3',eid,'C',fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00703             self.obj.add(self.elementType,dt,data)
00704             
00705             if self.makeOp2Debug:
00706                 self.op2Debug.write('%s\n' %(str(out)))
00707         ###
00708 
00709     def xOES_CPENTANL_91_alt(self):
00710         """
00711         The DMAP manual says fields 3-18 repeat 7 times. but they dont.
00712         They repeat 6 times.  Other DMAP cards are correct with
00713         their repeat statements.
00714         """
00715         #print "CHEXANL_93"
00716         #print "len(self.data) = ",len(self.data)
00717 
00718         raise NotImplementedError()
00719         n = 0
00720         dt = self.nonlinearFactor
00721         (format1,extract) = self.getOUG_FormatStart()
00722         format1 += '4s'
00723         format1 = bytes(format1)
00724 
00725         while len(self.data)>=456: # 2+16*7 = 114 -> 114*4 = 456
00726             eData = self.data[0:8]
00727             self.data = self.data[8:]
00728             (eid,cType) = unpack(format1,eData)
00729             eid = extract(eid,dt)
00730             #out = unpack('ii',eData)
00731             #(eid,cType) = out
00732 
00733             for i in xrange(7):
00734                 #print "len(self.data) = ",len(self.data)
00735                 eData = self.data[0:64]
00736                 self.data = self.data[64:]
00737                 out = unpack(b'ifffffffffffffff',eData)
00738                 assert len(out)==16
00739                 (grid,sx,sy,sz,sxy,syz,sxz,se,eps,ecs,ex,ey,ez,exy,eyz,exz) = out
00740                 #print "eid=%3s cType=%s sx=%i sy=%i sz=%i sxy=%s syz=%i szx=%i se=%s" %(eid,cType,sx,sy,sz,sxy,syz,sxz,se)
00741                 #print "gid=%3s ecs=%.3g   ex=%.3g ey=%.3g ez=%.3g exy=%.3g eyz=%.3g ezx=%.3g"  %(grid,ecs,ex,ey,ez,exy,eyz,exz)
00742                 #print ""
00743                 assert a=='G'
00744             
00745             #self.data = self.data[1456:]
00746             #sys.exit('hexa...')
00747         #print "buffer time..."
00748         #self.firstPass = True
00749 
00750     def xOES_CHEXANL_93_alt(self):
00751         """
00752         The DMAP manual says fields 3-18 repeat 9 times. but they dont.
00753         They repeat 8 times.  Other DMAP cards are correct with
00754         their repeat statements.
00755         """
00756         #print "CHEXANL_93"
00757         #print "len(self.data) = ",len(self.data)
00758 
00759         raise NotImplementedError()
00760         n = 0
00761         dt = self.nonlinearFactor
00762         (format1,extract) = self.getOUG_FormatStart()
00763         format1 += '4s'
00764         format1 = bytes(format1)
00765 
00766         while len(self.data)>=584: # 2+16*9 = 146 -> 146*4 = 584
00767             eData = self.data[0:8]
00768             self.data = self.data[8:]
00769             (eid,cType) = unpack(format1,eData)
00770             eid = extract(eid,dt)
00771             #out = unpack(b'ii',eData)
00772             #(eid,cType) = out
00773 
00774             for i in xrange(9):
00775                 #print "len(self.data) = ",len(self.data)
00776                 eData = self.data[0:64] # 4*16
00777                 self.data = self.data[64:]
00778                 out = unpack(b'ifffffffffffffff',eData)
00779                 assert len(out)==16
00780                 (grid,sx,sy,sz,sxy,syz,sxz,se,eps,ecs,ex,ey,ez,exy,eyz,exz) = out
00781                 #print "eid=%3s cType=%s sx=%i sy=%i sz=%i sxy=%s syz=%i szx=%i se=%s" %(eid,cType,sx,sy,sz,sxy,syz,sxz,se)
00782                 #print "gid=%3s ecs=%.3g   ex=%.3g ey=%.3g ez=%.3g exy=%.3g eyz=%.3g ezx=%.3g"  %(grid,ecs,ex,ey,ez,exy,eyz,exz)
00783                 #print ""
00784                 assert a=='G'
00785             
00786             #self.data = self.data[1456:]
00787             #sys.exit('hexa...')
00788         #print "buffer time..."
00789         #self.firstPass = True
00790 
00791     def OES_CBEAM_94_alt(self):
00792         raise NotImplementedError()
00793         nNodes = 10 # 11-1
00794 
00795         #nTotal       = self.obj.getLengthTotal()
00796         #(n1,format1) = self.obj.getLength1()
00797         #(n2,format2) = self.obj.getLength2()
00798         nTotal = 2*4 + (18-3)*9*4
00799         nTotal = 204
00800 
00801         n1 = 24
00802         format1 = '4sfffff'
00803         format1 = bytes(format1)
00804 
00805         while len(self.data)>=nTotal:
00806             eData     = self.data[0:8]
00807             self.data = self.data[8: ]
00808             (eid,gridA) = unpack(b'ii', eData)
00809             #print "eid=%s gridA=%s" %(eid,gridA)
00810 
00811             for i in xrange(1):
00812                 for j in xrange(4): # c,d,e,f @ A;    c,d,e,f @ B
00813                     eData     = self.data[0:n1]
00814                     self.data = self.data[n1: ]
00815                     out = unpack(format1, eData)
00816                     (loc,nsx,nse,te,epe,ece) = out
00817                     #print "loc=%s nsx=%s nse=%s te=%s epe=%s ece=%s" %(loc,nsx,nse,te,epe,ece)
00818                 ###
00819                 #self.obj.add(eid,out)
00820             ###
00821             #sys.exit('stoping in CBEAM_94')
00822 
00823         #raise Exception('add CBEAM-94...')
00824 
00825     def xOES_CQUAD4_95_alt(self): # works (doesnt handle all stress/strain cases tho)
00826         """
00827         GRID-ID  DISTANCE,NORMAL-X,NORMAL-Y,SHEAR-XY,ANGLE,MAJOR MINOR,VONMISES
00828         """
00829         eType = self.ElementType(self.elementType)
00830 
00831         #self.printSection(20)
00832         #term = data[0:4] CEN/
00833         #data = data[4:]
00834         assert self.numWide==11,'invalid numWide...numWide=%s' %(self.numWide)
00835 
00836         dt = self.nonlinearFactor
00837         (format1,extract) = self.getOUG_FormatStart()
00838         format1 += 'ifffffffff'
00839         format1 = bytes(format1)
00840 
00841         while len(self.data)>=44: # 2+17*5 = 87 -> 87*4 = 348
00842             eData     = self.data[0:44] # 4*11=44
00843             self.data = self.data[44: ]
00844             out = unpack(format1,eData)
00845             if self.makeOp2Debug:
00846                 self.op2Debug.write('%s\n' %(str(out)))
00847             (eid,iLayer,o1,o2,t12,t1z,t2z,angle,major,minor,ovm) = out
00848             #print "out =",out
00849             eid = extract(eid,dt)
00850             
00851             if eid!=self.eid2: # originally initialized to None, the buffer doesnt reset it, so it is the old value
00852                 #print "1 - eid=%s iLayer=%i o1=%i o2=%i ovm=%i" %(eid,iLayer,o1,o2,ovm)
00853                 self.obj.addNewEid(eType,dt,eid,o1,o2,t12,t1z,t2z,angle,major,minor,ovm)
00854             else:
00855                 #print "2 - eid=%s iLayer=%i o1=%i o2=%i ovm=%i" %(eid,iLayer,o1,o2,ovm)
00856                 self.obj.add(dt,eid,o1,o2,t12,t1z,t2z,angle,major,minor,ovm)
00857             ###
00858             self.eid2 = eid
00859             #self.dn += 348
00860         ###
00861         #print "3 - eid=%s iLayer=%i o1=%i o2=%i ovm=%i" %(eid,iLayer,o1,o2,ovm)
00862         #self.printSection(100)
00863 
00864     def xOES_QUAD4FD_139(self): # hyperelastic
00865         """
00866         Hyperelastic Quad
00867         36+4*7*4 = 148
00868         """
00869         raise NotImplementedError()
00870         #x = 0
00871         dt = self.nonlinearFactor
00872         (format1,extract) = self.getOUG_FormatStart()
00873         format1 += '4siffffff'
00874         format1 = bytes(format1)
00875 
00876         while len(self.data)>=148:
00877             #if x==2:
00878             #    sys.exit('end of hyperQuad')
00879             eData     = self.data[0:36] # 4*9=36
00880             self.data = self.data[36: ]
00881             out = unpack(format1,eData)
00882 
00883             (eid,Type,ID,sx,sy,sxy,angle,smj,smi) = out
00884             eid = extract(eid,dt)
00885             self.obj.addNewEid(dt,[eid,Type,sx,sy,sxy,angle,smj,smi])
00886             #print "eid=%s Type=%s\n***ID=%s sx=%s sy=%s sxy=%s angle=%s major=%s minor=%s" %(eid,Type,ID,sx,sy,sxy,angle,smj,smi)
00887             for i in xrange(3):
00888                 eData     = self.data[0:28] #4*7=28
00889                 self.data = self.data[28: ]
00890                 out = unpack(b'iffffff',eData)
00891                 #(ID,sx,sy,sxy,angle,smj,smi) = out
00892                 self.obj.add(dt,eid,out)
00893                 #print "***ID=%s sx=%s sy=%s sxy=%s angle=%s major=%s minor=%s" %(ID,sx,sy,sxy,angle,smj,smi)
00894             ###
00895             #self.obj.add(data)
00896             #x+=1
00897             if self.makeOp2Debug:
00898                 self.op2Debug.write('%s\n' %(str(out)))
00899         ###
00900         #sys.exit('end of hyperQuad')
00901     
00902     def xOES_CQUADR_82_alt(self): # not done...
00903         """
00904         GRID-ID  DISTANCE,NORMAL-X,NORMAL-Y,SHEAR-XY,ANGLE,MAJOR MINOR,VONMISES
00905         """
00906         raise NotImplementedError()
00907         if self.elementType==82: # CQUADR
00908             nTotal = 348  # 2+17*5 = 87 -> 87*4 = 348
00909             nNodes = 4    # centroid + 4 corner points
00910             eType  = 'CQUADR'
00911         else:
00912             raise Exception('elementType=%s nTotal not defined...' %(self.elementType))
00913 
00914         dt = self.nonlinearFactor
00915         (format1,extract) = self.getOUG_FormatStart()
00916         format1 += 'ffffffffffffffff'
00917         format1 = bytes(format1)
00918 
00919         while len(self.data)>=nTotal:
00920             (eid,_) = unpack(b'i4s',self.data[0:8])
00921             self.data = self.data[8:]  # 2
00922             eid = extract(eid,dt)
00923             eData     = self.data[0:68]
00924             self.data = self.data[68: ]
00925             out = unpack(format1,eData)  # len=17*4
00926             if self.makeOp2Debug:
00927                 self.op2Debug.write('%s\n' %(str(out)))
00928             (grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1,
00929                   fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2,) = out
00930             grid = 'C'
00931             self.obj.addNewEid(eType,eid,grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00932             self.obj.add(            eid,grid,fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00933 
00934             for nodeID in xrange(nNodes):   #nodes pts
00935                 eData     = self.data[0:68] # 4*17=68
00936                 self.data = self.data[68: ]
00937                 out = unpack(b'iffffffffffffffff',eData)
00938                 if self.makeOp2Debug:
00939                     self.op2Debug.write('%s\n' %(str(out)))
00940                 (grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1,
00941                       fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2,) = out
00942 
00943                 #print "eid=%i grid=%i fd1=%i sx1=%i sy1=%i txy1=%i angle1=%i major1=%i minor1=%i vm1=%i" %(eid,grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00944                 #print "               fd2=%i sx2=%i sy2=%i txy2=%i angle2=%i major2=%i minor2=%i vm2=%i\n"          %(fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00945                 #print "len(data) = ",len(self.data)
00946                 #self.printBlock(self.data)
00947                 self.obj.addNewNode(eid,grid,fd1,sx1,sy1,txy1,angle1,major1,minor1,vm1)
00948                 self.obj.add(       eid,grid,fd2,sx2,sy2,txy2,angle2,major2,minor2,vm2)
00949             ###
00950         ###
00951 
 All Classes Namespaces Files Functions Variables