pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
realForces.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 
00031 class RealForces(object):
00032 
00033     def OEF_aCode(self):
00034         if self.analysisCode==1:   # statics
00035             format1 = 'i' # loadID
00036             #self.addDataParameter(data,'loadID','i',5,False)   ## load set ID number
00037         elif self.analysisCode==2: # normal modes/buckling (real eigenvalues)
00038             format1 = 'i' # mode
00039             #self.addDataParameter(data,'mode','i',5)   ## mode number
00040             #self.addDataParameter(data,'eign','f',6,False)   ## eigenvalue
00041         elif self.analysisCode==3: # differential stiffness 0
00042             format1 = 'i' #loadID
00043             #self.addDataParameter(data,'loadID','i',5)   ## load set ID number
00044         elif self.analysisCode==4: # differential stiffness 1
00045             format1 = 'i' #loadID
00046             self.addDataParameter(data,'loadID','i',5)   ## load set ID number
00047         elif self.analysisCode==5:   # frequency
00048             format1 = 'f' # freq
00049             #self.addDataParameter(data,'freq','f',5)   ## frequency
00050 
00051         elif self.analysisCode==6: # transient
00052             format1 = 'f' # time
00053             #self.addDataParameter(data,'time','f',5)   ## time step
00054             #print "time(5)=%s" %(self.time)
00055         elif self.analysisCode==7: # pre-buckling
00056             format1 = 'i' # loadID
00057             #self.addDataParameter(data,'loadID','i',5)   ## load set ID number
00058             #print "loadID(5)=%s" %(self.loadID)
00059         elif self.analysisCode==8: # post-buckling
00060             format1 = 'i' # loadID
00061             #self.addDataParameter(data,'loadID','i',5)       ## load set ID number
00062             #self.addDataParameter(data,'eigr','f',6,False)   ## real eigenvalue
00063             #print "loadID(5)=%s  eigr(6)=%s" %(self.loadID,self.eigr)
00064         elif self.analysisCode==9: # complex eigenvalues
00065             format1 = 'i' # mode
00066             #self.addDataParameter(data,'mode','i',5)         ## mode number
00067             #self.addDataParameter(data,'eigr','f',6,False)   ## real eigenvalue
00068             #self.addDataParameter(data,'eigi','f',7,False)   ## imaginary eigenvalue
00069             #print "mode(5)=%s  eigr(6)=%s  eigi(7)=%s" %(self.mode,self.eigr,self.eigi)
00070         elif self.analysisCode==10: # nonlinear statics
00071             format1 = 'f' # loadStep
00072             self.addDataParameter(data,'loadStep','f',5)   ## load step
00073             #print "loadStep(5) = %s" %(self.loadStep)
00074         elif self.analysisCode==11: # geometric nonlinear statics
00075             format1 = 'i' # loadID
00076             #self.addDataParameter(data,'loadID','i',5)   ## load set ID number
00077             #print "loadID(5)=%s" %(self.loadID)
00078         else:
00079             raise RuntimeError('invalid analysisCode...analysisCode=%s' %(str(self.analysisCode)+'\n'+self.codeInformation()))
00080         return format1
00081 
00082     def getOEF_FormatStart(self):
00083         """
00084         Returns an i or an f depending on if it's SORT2 or not.
00085         Also returns an extraction function that is called on the first argument
00086         """
00087         isSort1 = self.isSort1()
00088         if isSort1:
00089             #print "SORT1 - %s" %(self.ElementType(self.elementType))
00090             format1 = 'i' # SORT1
00091             extract = self.extractSort1
00092             #dt = self.nonlinearFactor
00093         else:
00094             #print "SORT2 - %s" %(self.ElementType(self.elementType))
00095             format1 = 'f' # SORT2
00096             extract = self.extractSort2
00097             #eid = self.nonlinearFactor
00098         return (format1,extract)
00099 
00100     def OEF_Rod(self): # 1-CROD, 3-CTUBE, 10-CONROD
00101         dt = self.nonlinearFactor
00102         (format1,extract) = self.getOEF_FormatStart()
00103         format1 += 'ff'
00104         format1 = bytes(format1)
00105 
00106         while len(self.data)>=12: # 3*4
00107             eData     = self.data[0:12]
00108             self.data = self.data[12: ]
00109             #print "len(data) = ",len(eData)
00110 
00111             out = unpack(format1, eData)
00112             (eid,axial,torque) = out
00113             eid2  = extract(eid,dt)
00114             #print "eType=%s" %(eType)
00115             
00116             dataIn = [eid2,axial,torque]
00117             #print "%s" %(self.ElementType(self.elementType)),dataIn
00118             #eid = self.obj.addNewEid(out)
00119             self.obj.add(dt,dataIn)
00120             #print "len(data) = ",len(self.data)
00121         ###
00122         #print self.rodForces
00123         
00124     def OEF_CVisc(self): # 24-CVISC
00125         dt = self.nonlinearFactor
00126         (format1,extract) = self.getOEF_FormatStart()
00127         format1 += 'ff'
00128         format1 = bytes(format1)
00129 
00130         while len(self.data)>=12: # 3*4
00131             eData     = self.data[0:12]
00132             self.data = self.data[12: ]
00133             #print "len(data) = ",len(eData)
00134 
00135             out = unpack(format1, eData)
00136             (eid,axial,torque) = out
00137             eid2  = extract(eid,dt)
00138             #print "eType=%s" %(eType)
00139             
00140             dataIn = [eid2,axial,torque]
00141             #print "%s" %(self.ElementType(self.elementType)),dataIn
00142             #eid = self.obj.addNewEid(out)
00143             self.obj.add(dt,dataIn)
00144             #print "len(data) = ",len(self.data)
00145         ###
00146         #print self.viscForces
00147         
00148     def OEF_Beam(self): # 2-CBEAM   ## @todo is this correct???
00149         dt = self.nonlinearFactor
00150         (format1,extract) = self.getOEF_FormatStart()
00151         #print self.codeInformation()
00152         formatAll = 'iffffffff'
00153         format1 = bytes(format1)
00154         formatAll = bytes(formatAll)
00155 
00156         while len(self.data)>=400: # 1+(10-1)*11=100 ->100*4 = 400
00157             #print "eType=%s" %(eType)
00158 
00159             eData     = self.data[0:4]
00160             self.data = self.data[4: ]
00161             eid, = unpack(format1, eData)
00162             eid2 = extract(eid,dt)
00163 
00164             for i in xrange(11):
00165                 eData     = self.data[0:36]
00166                 self.data = self.data[36: ]
00167                 #print "len(data) = ",len(eData)
00168 
00169                 out = unpack(formatAll, eData)
00170                 (nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq) = out
00171                 #print "eidTemp = ",eidTemp
00172                 #print "nid = ",nid
00173                 #print "sd = ",sd
00174 
00175                 dataIn = [eid2,nid,sd,bm1,bm2,ts1,ts2,af,ttrq,wtrq]
00176                 #print "%s        " %(self.ElementType(self.elementType)),dataIn
00177                 #eid = self.obj.addNewEid(out)
00178                 if i==0: #isNewElement:
00179                     self.obj.addNewElement(dt,dataIn)
00180                     #print
00181                 elif sd>0.:
00182                     self.obj.add(dt,dataIn)
00183                 #print
00184             #else: pass
00185 
00186             #print "len(data) = ",len(self.data)
00187         ###
00188         #print self.beamForces
00189 
00190     def OEF_Shear(self): # 4-CSHEAR
00191         dt = self.nonlinearFactor
00192         (format1,extract) = self.getOEF_FormatStart()
00193         format1 += 'ffffffffffffffff'
00194         format1 = bytes(format1)
00195 
00196         while len(self.data)>=68: # 17*4
00197             eData     = self.data[0:68]
00198             self.data = self.data[68: ]
00199             #print "len(data) = ",len(eData)
00200 
00201             out = unpack(format1, eData)
00202             (eid,f41,f21,f12,f32,f23,f43,f34,f14,kf1,s12,kf2,s23,kf3,s34,kf4,s41) = out
00203             eid2  = extract(eid,dt)
00204             #print "eType=%s" %(eType)
00205             
00206             dataIn = [eid2,f41,f21,f12,f32,f23,f43,f34,f14,kf1,s12,kf2,s23,kf3,s34,kf4,s41]
00207             #print "%s" %(self.ElementType(self.elementType)),dataIn
00208             #eid = self.obj.addNewEid(out)
00209             self.obj.add(dt,dataIn)
00210             #print "len(data) = ",len(self.data)
00211         ###
00212         #print self.shearForces
00213         
00214     def OEF_Spring(self): # 11-CELAS1, 12-CELAS2, 13-CELAS3, 14-CELAS4
00215         dt = self.nonlinearFactor
00216         (format1,extract) = self.getOEF_FormatStart()
00217         format1 += 'f'
00218         format1 = bytes(format1)
00219 
00220         while len(self.data)>=8: # 2*4
00221             eData     = self.data[0:8]
00222             self.data = self.data[8: ]
00223             #print "len(data) = ",len(eData)
00224 
00225             out = unpack(format1, eData)
00226             (eid,force) = out
00227             eid2  = extract(eid,dt)
00228             #print "eType=%s" %(eType)
00229             
00230             dataIn = [eid2,force]
00231             #print "%s" %(self.ElementType(self.elementType)),dataIn
00232             #eid = self.obj.addNewEid(out)
00233             self.obj.add(dt,dataIn)
00234             #print "len(data) = ",len(self.data)
00235         ###
00236         #print self.springForces
00237         
00238     def OEF_CBar(self): # 34-CBAR
00239         dt = self.nonlinearFactor
00240         (format1,extract) = self.getOEF_FormatStart()
00241         format1 += 'ffffffff'
00242         format1 = bytes(format1)
00243 
00244         while len(self.data)>=36: # 9*4
00245             eData     = self.data[0:36]
00246             self.data = self.data[36: ]
00247             #print "len(data) = ",len(eData)
00248 
00249             out = unpack(format1, eData)
00250             (eid,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq) = out
00251             eid2  = extract(eid,dt)
00252             #print "eType=%s" %(eType)
00253             
00254             dataIn = [eid2,bm1a,bm2a,bm1b,bm2b,ts1,ts2,af,trq]
00255             #print "%s" %(self.ElementType(self.elementType)),dataIn
00256             #eid = self.obj.addNewEid(out)
00257             self.obj.add(dt,dataIn)
00258             #print "len(data) = ",len(self.data)
00259         ###
00260         #print self.barForces
00261         
00262     def OEF_CBar100(self): # 100-CBAR
00263         dt = self.nonlinearFactor
00264         (format1,extract) = self.getOEF_FormatStart()
00265         format1 += 'fffffff'
00266         format1 = bytes(format1)
00267 
00268         while len(self.data)>=36: # 9*4
00269             eData     = self.data[0:32]
00270             self.data = self.data[32: ]
00271             #print "len(data) = ",len(eData)
00272 
00273             out = unpack(format1, eData)
00274             (eid,sd,bm1,bm2,ts1,ts2,af,trq) = out
00275             eid2  = extract(eid,dt)
00276             #print "eType=%s" %(eType)
00277             
00278             dataIn = [eid2,sd,bm1,bm2,ts1,ts2,af,trq]
00279             #print "%s" %(self.ElementType(self.elementType)),dataIn
00280             #eid = self.obj.addNewEid(out)
00281             self.obj.add(dt,dataIn)
00282             #print "len(data) = ",len(self.data)
00283         ###
00284         #print self.bar100Forces
00285         
00286     def OEF_Plate(self): # 33-CQUAD4,74-CTRIA3
00287         dt = self.nonlinearFactor
00288         (format1,extract) = self.getOEF_FormatStart()
00289         format1 += 'ffffffff'
00290         format1 = bytes(format1)
00291 
00292         while len(self.data)>=36: # 9*4
00293             eData     = self.data[0:36]
00294             self.data = self.data[36: ]
00295             #print "len(data) = ",len(eData)
00296 
00297             out = unpack(format1, eData)
00298             (eid,mx,my,mxy,bmx,bmy,bmxy,tx,ty) = out
00299             eid2  = extract(eid,dt)
00300             #print "eType=%s" %(eType)
00301             
00302             dataIn = [eid2,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00303             #print "%s" %(self.ElementType(self.elementType)),dataIn
00304             #eid = self.obj.addNewEid(out)
00305             self.obj.add(dt,dataIn)
00306             #print "len(data) = ",len(self.data)
00307         ###
00308         #print self.plateForces
00309 
00310     def OEF_Plate2(self): # 64-CQUAD8,70-CTRIAR,75-CTRIA6,82-CQUAD8,144-CQUAD4-bilinear
00311         dt = self.nonlinearFactor
00312         (format1,extract) = self.getOEF_FormatStart()
00313         format1 += '4s'
00314 
00315         if self.elementType in [70,75]: # CTRIAR,CTRIA6
00316             nNodes = 4
00317         elif self.elementType in [64,82,144]: # CQUAD8,CQUADR,CQUAD4-bilinear
00318             nNodes = 5
00319         else:
00320             raise NotImplementedError(self.codeInformation())
00321         ###
00322 
00323         allFormat = 'fffffffff'
00324         format1 = bytes(format1)
00325         allFormat = bytes(allFormat)
00326 
00327         nTotal = 44+nNodes*36
00328         while len(self.data)>=nTotal:
00329             eData     = self.data[0:44]
00330             self.data = self.data[44: ]
00331             #print self.printBlock(eData)
00332             #print "len(data) = ",len(eData)
00333 
00334             out = unpack(format1+allFormat, eData)
00335             (eid,term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty) = out
00336             #term= 'CEN\'
00337             #print "eType=%s" %(eType)
00338 
00339             eid2  = extract(eid,dt)
00340             
00341             dataIn = [term,nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00342             #print "%s" %(self.ElementType(self.elementType)),dataIn
00343             self.obj.addNewElement(eid2,dt,dataIn)
00344 
00345             for i in xrange(nNodes-1):
00346                 eData     = self.data[0:36]
00347                 self.data = self.data[36: ]
00348                 dataIn = unpack(allFormat, eData)
00349                 #(nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty) = out
00350                 #dataIn = [nid,mx,my,mxy,bmx,bmy,bmxy,tx,ty]
00351                 #print "***%s    " %(self.ElementType(self.elementType)),dataIn
00352                 
00353                 self.obj.add(eid2,dt,dataIn)
00354                 #print "len(data) = ",len(self.data)
00355             ###
00356         ###
00357         #sys.exit('Plate2 stop...')
00358         #print self.plateForces2
00359 
00360     def OEF_ConeAx(self): # 35-CCONEAX
00361         dt = self.nonlinearFactor
00362         (format1,extract) = self.getOEF_FormatStart()
00363         format1 += '6f'
00364         format1 = bytes(format1)
00365 
00366         while len(self.data)>=28: # 7*4
00367             eData     = self.data[0:28]
00368             self.data = self.data[28: ]
00369             #print "len(data) = ",len(eData)
00370 
00371             out = unpack(format1, eData)
00372             (eid,hopa,bmu,bmv,tm,su,sv) = out
00373             eid2  = extract(eid,dt)
00374             #print "eType=%s" %(eType)
00375             
00376             dataIn = [eid2,hopa,bmu,bmv,tm,su,sv]
00377             #print "%s" %(self.ElementType(self.elementType)),dataIn
00378             #eid = self.obj.addNewEid(out)
00379             self.obj.add(dt,dataIn)
00380             #print "len(data) = ",len(self.data)
00381         ###
00382         #print self.shearForces
00383         
00384     def OEF_CGap(self): # 38-CGAP
00385         dt = self.nonlinearFactor
00386         (format1,extract) = self.getOEF_FormatStart()
00387         format1 += 'ffffffff'
00388         format1 = bytes(format1)
00389 
00390         while len(self.data)>=36: # 9*4
00391             eData     = self.data[0:36]
00392             self.data = self.data[36: ]
00393             #print "len(data) = ",len(eData)
00394 
00395             out = unpack(format1, eData)
00396             (eid,fx,sfy,sfz,u,v,w,sv,sw) = out
00397             eid2  = extract(eid,dt)
00398             #print "eType=%s" %(eType)
00399             
00400             dataIn = [eid2,fx,sfy,sfz,u,v,w,sv,sw]
00401             #print "%s" %(self.ElementType(self.elementType)),dataIn
00402             #eid = self.obj.addNewEid(out)
00403             self.obj.add(dt,dataIn)
00404             #print "len(data) = ",len(self.data)
00405         ###
00406         #print self.plateForces
00407 
00408     def OEF_Bend(self): # 69-CBEND
00409         dt = self.nonlinearFactor
00410         (format1,extract) = self.getOEF_FormatStart()
00411         format1 += 'i13f'
00412         format1 = bytes(format1)
00413 
00414         while len(self.data)>=60: # 15*4
00415             eData     = self.data[0:60]
00416             self.data = self.data[60: ]
00417             #print "len(data) = ",len(eData)
00418 
00419             out = unpack(format1, eData)
00420             (eid,nidA,bm1A,bm2A,ts1A,ts2A,afA,trqA,
00421                  nidB,bm1B,bm2B,ts1B,ts2B,afB,trqB) = out
00422             eid2  = extract(eid,dt)
00423             #print "eType=%s" %(eType)
00424             
00425             dataIn = [eid2,nidA,bm1A,bm2A,ts1A,ts2A,afA,trqA,
00426                            nidB,bm1B,bm2B,ts1B,ts2B,afB,trqB]
00427             #print "%s" %(self.ElementType(self.elementType)),dataIn
00428             #eid = self.obj.addNewEid(out)
00429             self.obj.add(dt,dataIn)
00430             #print "len(data) = ",len(self.data)
00431         ###
00432         #print self.bendForces
00433         
00434     def OEF_PentaPressure(self): # 77-CPENTA_PR,78-CTETRA_PR
00435         dt = self.nonlinearFactor
00436         (format1,extract) = self.getOEF_FormatStart()
00437         format1 += '8s7f'
00438         format1 = bytes(format1)
00439 
00440         while len(self.data)>=40: # 10*4
00441             eData     = self.data[0:40]
00442             self.data = self.data[40: ]
00443             #print "len(data) = ",len(eData)
00444 
00445             out = unpack(format1, eData)
00446             (eid,eName,ax,ay,az,vx,vy,vz,pressure) = out
00447             eid2  = extract(eid,dt)
00448             #print "eType=%s" %(eType)
00449             
00450             dataIn = [eid2,eName,ax,ay,az,vx,vy,vz,pressure]
00451             #print "%s" %(self.ElementType(self.elementType)),dataIn
00452             #eid = self.obj.addNewEid(out)
00453             self.obj.add(dt,dataIn)
00454             #print "len(data) = ",len(self.data)
00455         ###
00456         #print self.pentaPressureForces
00457         
00458     def OEF_CBush(self): # 102-CBUSH
00459         dt = self.nonlinearFactor
00460         (format1,extract) = self.getOEF_FormatStart()
00461         format1 += '6f'
00462         format1 = bytes(format1)
00463 
00464         while len(self.data)>=28: # 7*4
00465             eData     = self.data[0:28]
00466             self.data = self.data[28: ]
00467             #print "len(data) = ",len(eData)
00468 
00469             out = unpack(format1, eData)
00470             (eid,fx,fy,fz,mx,my,mz) = out
00471             eid2  = extract(eid,dt)
00472             #print "eType=%s" %(eType)
00473             
00474             dataIn = [eid2,fx,fy,fz,mx,my,mz]
00475             #print "%s" %(self.ElementType(self.elementType)),dataIn
00476             #eid = self.obj.addNewEid(out)
00477             self.obj.add(dt,dataIn)
00478             #print "len(data) = ",len(self.data)
00479         ###
00480         #print self.bushForces
00481 
00482     def OEF_Force_VU(self): # 191-VUBEAM
00483         dt = self.nonlinearFactor
00484 
00485         (format1,extract) = self.getOEF_FormatStart()
00486         format1 += 'ii4s'
00487 
00488         if self.elementType in [191]:
00489             nNodes = 2
00490         else:
00491             raise NotImplementedError(self.codeInformation())
00492 
00493         formatAll = 'i7f'
00494         format1 = bytes(format1)
00495         formatAll = bytes(formatAll)
00496 
00497         n = 16+32*nNodes
00498         while len(self.data)>=n:
00499             eData     = self.data[0:16] # 8*4
00500             self.data = self.data[16: ]
00501             #print "len(data) = ",len(eData)
00502 
00503             out = unpack(format1, eData)
00504             (eid,parent,coord,icord) = out
00505 
00506             eid2  = extract(eid,dt)
00507             dataIn = [eid2,parent,coord,icord]
00508 
00509             forces = []
00510             for i in xrange(nNodes):
00511                 eData     = self.data[0:32] # 8*4
00512                 self.data = self.data[32: ]
00513                 #print "i=%s len(data)=%s" %(i,len(eData))
00514                 out = unpack(formatAll, eData)
00515                 forces.append(out)
00516             dataIn.append(forces)
00517             #eType = a+b+c+d+e+f+g+h
00518             #print "eType=%s" %(eType)
00519             
00520             #dataIn = [vugrid,posit,forceX,shearY,shearZ,torsion,bendY,bendZ]
00521             #print "force %s" %(self.ElementType(self.elementType)),dataIn
00522             #eid = self.obj.addNewEid(out)            
00523             self.obj.add(nNodes,dt,dataIn)
00524             #print "len(data) = ",len(self.data)
00525         ###
00526         if self.makeOp2Debug:
00527             print("done with OEF_Force_VU")
00528         #print(self.force_VU)
00529 
00530     def OEF_Force_VUTRIA(self): # 189-VUQUAD,190-VUTRIA
00531         dt = self.nonlinearFactor
00532         (format1,extract) = self.getOEF_FormatStart()
00533         format1 += 'ii4sii'
00534 
00535         if self.elementType in [189]: # VUQUAD
00536             nNodes = 4
00537         elif self.elementType in [190]: # VUTRIA
00538             nNodes = 3
00539         else:
00540             raise NotImplementedError(self.codeInformation())
00541 
00542         formatAll = 'ifffiiifffffi'
00543         format1 = bytes(format1)
00544         formatAll = bytes(formatAll)
00545         n = 24+52*nNodes
00546         while len(self.data)>=n:
00547             eData     = self.data[0:24] # 6*4
00548             self.data = self.data[24: ]
00549             #print "len(data) = ",len(eData)
00550 
00551             out = unpack(format1, eData)
00552             (eid,parent,coord,icord,theta,_) = out
00553 
00554             eid2  = extract(eid,dt)
00555             dataIn = [eid2,parent,coord,icord,theta]
00556 
00557             forces = []
00558             for i in xrange(nNodes):
00559                 eData     = self.data[0:52] # 13*4
00560                 self.data = self.data[52: ]
00561                 #print "i=%s len(data)=%s" %(i,len(eData))
00562                 out = unpack(formatAll, eData)
00563                 (vugrid,mfx,mfy,mfxy,a,b,c,bmx,bmy,bmxy,syz,szx,d) = out
00564                 out2 = (vugrid,mfx,mfy,mfxy,bmx,bmy,bmxy,syz,szx)
00565                 forces.append(out2)
00566             dataIn.append(forces)
00567             #eType = a+b+c+d+e+f+g+h
00568             #print "eType=%s" %(eType)
00569             
00570             #dataIn = [vugrid,mfx,mfy,mfxy,a,b,c,bmx,bmy,bmxy,syz,szx,d]
00571             #print "force %s" %(self.ElementType(self.elementType)),dataIn
00572             #eid = self.obj.addNewEid(out)            
00573             self.obj.add(nNodes,dt,dataIn)
00574             #print "len(data) = ",len(self.data)
00575         ###
00576         if self.makeOp2Debug:
00577             print("done with OEF_Force_VUTRIA")
00578         #print(self.force_VU_2D)
00579 
 All Classes Namespaces Files Functions Variables