pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
oes.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 from pyNastran.op2.tables.oes_stressStrain.real.oes_rods   import RodStressObject,RodStrainObject
00026 from pyNastran.op2.tables.oes_stressStrain.real.oes_bars   import BarStressObject,BarStrainObject
00027 #from pyNastran.op2.tables.oes_stressStrain.real.oes_beams   import beamStressObject
00028 #from pyNastran.op2.tables.oes_stressStrain.real.oes_shear   import shearStressObject
00029 from pyNastran.op2.tables.oes_stressStrain.real.oes_solids import SolidStressObject,SolidStrainObject
00030 from pyNastran.op2.tables.oes_stressStrain.real.oes_plates import PlateStressObject,PlateStrainObject
00031 from pyNastran.op2.tables.oes_stressStrain.real.oes_compositePlates import CompositePlateStressObject
00032 
00033 #strain...
00034 
00035 class OES(object):
00036     def __init__(self):
00037         self.rodStress  = {} # CROD, CONROD, CTUBE
00038         self.rodStrain  = {}
00039 
00040         self.barStress  = {} # CBAR
00041         self.barStrain  = {}
00042 
00043         self.plateStress = {} # isotropic CTRIA3/CQUAD4
00044         self.plateStrain = {}
00045 
00046         self.solidStress = {} # CTETRA/CPENTA/CHEXA
00047         self.solidStrain = {}
00048 
00049         self.compositePlateStress = {}  # composite CTRIA3/CQUAD4
00050         self.compositePlateStrain = {}
00051 
00052         #-------------
00053         # not supported
00054         self.celasStress   = {} # CELASi
00055         self.celasStrain   = {}        
00056         self.beamStress = {} # CBEAM
00057         self.beamStrain = {}
00058         self.shearStress = {} # CSHEAR
00059         self.shearStrain = {}        
00060         self.nonlinearRodStress = {}  # CROD, CONROD, CTUBE
00061         self.nonlinearRodStrain = {}
00062         self.nonlinearPlateStress = {}  # CTRIA3, CTRIA6, CQUAD4, CQUAD8
00063         self.nonlinearPlateStrain = {}
00064         self.ctriaxStress = {} # CTRIAX6
00065         self.ctriaxStrain = {}
00066         self.hyperelasticPlateStress = {} # CTRIA3, CTRIA6, CQUAD4, CQUAD8
00067         self.hyperelasticPlateStrain = {}
00068 
00069     def getRodStress(self):
00070         """
00071                                      S T R E S S E S   I N   R O D   E L E M E N T S      ( C R O D )
00072         ELEMENT       AXIAL       SAFETY      TORSIONAL     SAFETY       ELEMENT       AXIAL       SAFETY      TORSIONAL     SAFETY
00073           ID.        STRESS       MARGIN        STRESS      MARGIN         ID.        STRESS       MARGIN        STRESS      MARGIN
00074              14    2.514247E+04              1.758725E+02                     15    2.443757E+04              2.924619E+01  
00075         """
00076         (iSubcase,transient,dataCode) = self.getRodHeader(False)
00077         dataCode['tableName'] = 'OES1X'
00078         data = self.readRodStress()
00079         if iSubcase in self.rodStress:
00080             self.rodStress[iSubcase].addF06Data(data,transient)
00081         else:
00082             isSort1 = True
00083             self.rodStress[iSubcase] = RodStressObject(dataCode,isSort1,iSubcase,transient)
00084             self.rodStress[iSubcase].addF06Data(data,transient)
00085         self.iSubcases.append(iSubcase)
00086     
00087     def getRodStrain(self):
00088         (iSubcase,transient,dataCode) = self.getRodHeader(False)
00089         dataCode['tableName'] = 'OSTR1X'
00090         data = self.readRodStress()
00091         if iSubcase in self.rodStrain:
00092             self.rodStrain[iSubcase].addF06Data(data,transient)
00093         else:
00094             isSort1 = True
00095             self.rodStrain[iSubcase] = RodStrainObject(dataCode,isSort1,iSubcase,transient)
00096             self.rodStrain[iSubcase].addF06Data(data,transient)
00097         self.iSubcases.append(iSubcase)
00098 
00099     def getRodHeader(self,isStrain):
00100         """
00101         analysisCode = 1 (Statics)
00102         deviceCode   = 1 (Print)
00103         tableCode    = 5 (Stress)
00104         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00105         formatCode   = 1 (Real)
00106         sCode        = 0 (Stress)
00107         numWide      = 8 (???)
00108         """
00109         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00110         headers = self.skip(2)
00111         #print "headers = %s" %(headers)
00112         
00113         (stressBits,sCode) = self.makeStressBits(isStrain=False,isRodOrSolid=True)
00114         dataCode = {'log':self.log, 'analysisCode':analysisCode,
00115                     'deviceCode':1, 'tableCode':5, 'sortCode':0,
00116                     'sortBits':[0,0,0], 'numWide':8, 'sCode':sCode,
00117                     'stressBits':stressBits, 'formatCode':1,
00118                     'elementName':'ROD','elementType':1, 'nonlinearFactor': dt,
00119                     }
00120         return (iSubcase,transient,dataCode)
00121 
00122     def readRodStress(self):
00123         """
00124                                      S T R E S S E S   I N   R O D   E L E M E N T S      ( C R O D )
00125         ELEMENT       AXIAL       SAFETY      TORSIONAL     SAFETY       ELEMENT       AXIAL       SAFETY      TORSIONAL     SAFETY
00126           ID.        STRESS       MARGIN        STRESS      MARGIN         ID.        STRESS       MARGIN        STRESS      MARGIN
00127              14    2.514247E+04              1.758725E+02                     15    2.443757E+04              2.924619E+01  
00128         """
00129         data = []
00130         while 1:
00131             line = self.infile.readline()[1:].rstrip('\r\n ')
00132             sline = [line[0:13],line[13:29],line[29:42],line[42:55],line[55:67],   line[67:78],line[78:94],line[94:107],line[107:120],line[120:131]]
00133             if 'PAGE' in line:
00134                 break
00135             #print sline
00136             out = self.parseLineBlanks(sline,[int,float,float,float,float, int,float,float,float,float]) # line 1
00137             #print out
00138             data.append(out[:5])
00139             if isinstance(out[5],int):
00140                 data.append(out[5:])
00141             self.i+=1
00142             ###
00143         ###
00144         return data
00145 
00146     def getBarStress(self):
00147         """
00148                                        S T R E S S E S   I N   B A R   E L E M E N T S          ( C B A R )
00149         ELEMENT        SA1            SA2            SA3            SA4           AXIAL          SA-MAX         SA-MIN     M.S.-T
00150           ID.          SB1            SB2            SB3            SB4           STRESS         SB-MAX         SB-MIN     M.S.-C
00151              12    0.0            0.0            0.0            0.0            1.020730E+04   1.020730E+04   1.020730E+04 
00152                    0.0            0.0            0.0            0.0                           1.020730E+04   1.020730E+04 
00153         analysisCode = 1 (Statics)
00154         deviceCode   = 1 (Print)
00155         tableCode    = 5 (Stress)
00156         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00157         formatCode   = 1 (Real)
00158         sCode        = 0 (Stress)
00159         numWide      = 8 (???)
00160         """
00161         (iSubcase,transient,dt,dataCode) = self.getBarHeader(False)
00162 
00163         data = self.readBarStress()
00164         dataCode['tableName'] = 'OES1X'
00165         if iSubcase in self.barStress:
00166             self.barStress[iSubcase].addF06Data(data,transient)
00167         else:
00168             isSort1 = True
00169             self.barStress[iSubcase] = BarStressObject(dataCode,isSort1,iSubcase,dt)
00170             self.barStress[iSubcase].addF06Data(data,transient)
00171         self.iSubcases.append(iSubcase)
00172     
00173     def getBarStrain(self):
00174         (iSubcase,transient,dt,dataCode) = self.getBarHeader(False)
00175         dataCode['tableName'] = 'OSTR1X'
00176 
00177         data = self.readBarStress()
00178         if iSubcase in self.barStrain:
00179             self.barStrain[iSubcase].addF06Data(data,transient)
00180         else:
00181             isSort1 = True
00182             self.barStrain[iSubcase] = BarStrainObject(dataCode,isSort1,iSubcase,dt)
00183             self.barStrain[iSubcase].addF06Data(data,transient)
00184         self.iSubcases.append(iSubcase)
00185 
00186     def getBarHeader(self,isStrain):
00187         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00188         headers = self.skip(2)
00189         #print "headers = %s" %(headers)
00190         
00191         (stressBits,sCode) = self.makeStressBits(isStrain=isStrain,isRodOrSolid=True)
00192         dataCode = {'log':self.log, 'analysisCode':analysisCode,
00193                     'deviceCode':1, 'tableCode':5, 'sortCode':0,
00194                     'sortBits':[0,0,0], 'numWide':8, 'sCode':sCode,
00195                     'stressBits':stressBits, 'formatCode':1,
00196                     'elementName':'CBAR', 'elementType':34,
00197                     'nonlinearFactor': dt,
00198                     }
00199         
00200         return (iSubcase,transient,dt,dataCode)
00201 
00202     def readBarStress(self):
00203         """
00204         ELEMENT        SA1            SA2            SA3            SA4           AXIAL          SA-MAX         SA-MIN     M.S.-T
00205           ID.          SB1            SB2            SB3            SB4           STRESS         SB-MAX         SB-MIN     M.S.-C
00206              12    0.0            0.0            0.0            0.0            1.020730E+04   1.020730E+04   1.020730E+04 
00207                    0.0            0.0            0.0            0.0                           1.020730E+04   1.020730E+04 
00208         """
00209         data = []
00210         while 1:
00211             line = self.infile.readline()[1:].rstrip('\r\n ')
00212             sline = [line[0:11],line[11:26],line[26:41],line[41:56],line[56:69],line[69:86],line[86:101],line[101:116],line[116:131]]
00213             if 'PAGE' in line:
00214                 break
00215             #print sline
00216             out = self.parseLineBlanks(sline,[int,float,float,float,float, float, float,float,float]) # line 1
00217             out = ['CBAR']+out
00218             #data.append(sline)
00219             line = self.infile.readline()[1:].rstrip('\r\n ')
00220             sline = [line[11:26],line[26:41],line[41:56],line[56:69],line[86:101],line[101:116],line[116:131]]
00221             #print sline
00222             out += self.parseLineBlanks(sline,[    float,float,float,float,        float,float,float]) # line 2
00223             #print "*",out
00224             data.append(out)
00225             self.i+=2
00226 
00227         return data
00228 
00229     def getQuadCompositeStress(self):
00230         """
00231                        S T R E S S E S   I N   L A Y E R E D   C O M P O S I T E   E L E M E N T S   ( Q U A D 4 )
00232         ELEMENT  PLY  STRESSES IN FIBER AND MATRIX DIRECTIONS    INTER-LAMINAR  STRESSES  PRINCIPAL STRESSES (ZERO SHEAR)      MAX
00233           ID      ID    NORMAL-1     NORMAL-2     SHEAR-12     SHEAR XZ-MAT  SHEAR YZ-MAT  ANGLE    MAJOR        MINOR        SHEAR
00234             181    1   3.18013E+04  5.33449E+05  1.01480E+03   -7.06668E+01  1.90232E+04   89.88  5.33451E+05  3.17993E+04  2.50826E+05
00235             181    2   1.41820E+05  1.40805E+05  1.25412E+05   -1.06000E+02  2.85348E+04   44.88  2.66726E+05  1.58996E+04  1.25413E+05
00236         
00237         elementType = 33 b/c not bilinear
00238         """
00239         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00240         headers = self.skip(2)
00241         #print "headers = %s" %(headers)
00242         data = self.readTable([int,int,float,float,float,float,float,float,float,float,float])
00243 
00244         isMaxShear = False  # Von Mises/Max Shear
00245         sHeaders = headers.rstrip()
00246         if 'SHEAR' in sHeaders[-5:]: # last 5 letters of the line to avoid 'SHEAR YZ-MAT'
00247             isMaxShear = True
00248         (stressBits,sCode) = self.makeStressBits(isMaxShear=isMaxShear,isStrain=False)
00249         dataCode = {'log':self.log, 'analysisCode':analysisCode,
00250                     'deviceCode':1, 'tableCode':5, 'sortCode':0,
00251                     'sortBits':[0,0,0], 'numWide':8, 'sCode':sCode,
00252                     'stressBits':stressBits, 'formatCode':1,
00253                     'elementName':'CQUAD4', 'elementType':33,
00254                     'tableName':'OES1X', 'nonlinearFactor': dt,
00255                     }
00256 
00257         if iSubcase in self.compositePlateStress:
00258             self.compositePlateStress[iSubcase].addF06Data(data,transient,'CQUAD4')
00259         else:
00260             assert 'nonlinearFactor' in dataCode
00261             self.compositePlateStress[iSubcase] = CompositePlateStressObject(dataCode,iSubcase,transient)
00262             self.compositePlateStress[iSubcase].addF06Data(data,transient,'CQUAD4')
00263         self.iSubcases.append(iSubcase)
00264         
00265     def getTriStress(self):
00266         """
00267                                  S T R E S S E S   I N   T R I A N G U L A R   E L E M E N T S   ( T R I A 3 )
00268         ELEMENT      FIBER               STRESSES IN ELEMENT COORD SYSTEM             PRINCIPAL STRESSES (ZERO SHEAR)                 
00269           ID.       DISTANCE           NORMAL-X       NORMAL-Y      SHEAR-XY       ANGLE         MAJOR           MINOR        VON MISES
00270               8   -1.250000E-01     -1.303003E+02   1.042750E+04  -1.456123E+02   -89.2100    1.042951E+04   -1.323082E+02   1.049629E+04
00271                    1.250000E-01     -5.049646E+02   1.005266E+04  -2.132942E+02   -88.8431    1.005697E+04   -5.092719E+02   1.032103E+04
00272         analysisCode = 1 (Statics)
00273         deviceCode   = 1 (Print)
00274         tableCode    = 5 (Stress)
00275         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00276         formatCode   = 1 (Real)
00277         sCode        = 0 (Stress)
00278         numWide      = 8 (???)
00279         """
00280         (iSubcase,transient,dataCode) = self.getTriHeader(False)
00281         dataCode['tableName']  = 'OES1X'
00282         data = self.readTriStress(['CTRIA3'])
00283         if iSubcase in self.plateStress:
00284             self.plateStress[iSubcase].addF06Data(data,transient)
00285         else:
00286             isSort1 = True
00287             self.plateStress[iSubcase] = PlateStressObject(dataCode,isSort1,iSubcase,transient)
00288             self.plateStress[iSubcase].addF06Data(data,transient)
00289         self.iSubcases.append(iSubcase)
00290 
00291     def getTriStrain(self):
00292         (iSubcase,transient,dataCode) = self.getTriHeader(True)
00293         dataCode['tableName']  = 'OST1X'
00294         data = self.readTriStress(['CTRIA3'])
00295         if iSubcase in self.plateStrain:
00296             self.plateStrain[iSubcase].addF06Data(data,transient)
00297         else:
00298             isSort1 = True
00299             assert 'nonlinearFactor' in dataCode
00300             self.plateStrain[iSubcase] = PlateStrainObject(dataCode,isSort1,iSubcase,transient)
00301             self.plateStrain[iSubcase].addF06Data(data,transient)
00302         self.iSubcases.append(iSubcase)
00303 
00304     def getTriHeader(self,isStrain):
00305         """
00306         analysisCode = 1 (Statics)
00307         deviceCode   = 1 (Print)
00308         tableCode    = 5 (Stress)
00309         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00310         formatCode   = 1 (Real)
00311         sCode        = 0 (Stress)
00312         numWide      = 8 (???)
00313         """
00314         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00315         headers = self.skip(2)
00316         #print "headers = %s" %(headers)
00317         
00318         isFiberDistance = False
00319         isMaxShear = False  # Von Mises/Max Shear
00320         if 'DISTANCE' in headers:
00321             isFiberDistance = True
00322         if 'MAX SHEAR' in headers:
00323             isMaxShear = True
00324         (stressBits,sCode) = self.makeStressBits(isFiberDistance,isMaxShear,isStrain=isStrain)
00325         dataCode = {'log':self.log, 'analysisCode':analysisCode,
00326                     'deviceCode':1, 'tableCode':5, 'sortCode':0,
00327                     'sortBits':[0,0,0], 'numWide':8, 'sCode':sCode,
00328                     'stressBits':stressBits, 'formatCode':1,
00329                     'elementName':'CTRIA3', 'elementType':74,
00330                     'nonlinearFactor': dt,
00331                     }
00332         return (iSubcase,transient,dataCode)
00333 
00334     def readTriStress(self,eType):
00335         """
00336                 ELEMENT      FIBER               STRESSES IN ELEMENT COORD SYSTEM             PRINCIPAL STRESSES (ZERO SHEAR)                 
00337                   ID.       DISTANCE           NORMAL-X       NORMAL-Y      SHEAR-XY       ANGLE         MAJOR           MINOR        VON MISES
00338                       8   -1.250000E-01     -1.303003E+02   1.042750E+04  -1.456123E+02   -89.2100    1.042951E+04   -1.323082E+02   1.049629E+04
00339                            1.250000E-01     -5.049646E+02   1.005266E+04  -2.132942E+02   -88.8431    1.005697E+04   -5.092719E+02   1.032103E+04
00340         """
00341         data = []
00342         while 1:
00343             line = self.infile.readline()[1:].strip().split()
00344             if 'PAGE' in line:
00345                 break
00346             #print line
00347             sline = self.parseLine(line,[int,float, float,float,float, float,float,float, float]) # line 1
00348             #print sline
00349             sline = eType+sline
00350             data.append(sline)
00351             line = self.infile.readline()[1:].strip().split()
00352             #print line
00353             sline += self.parseLine(line,[   float, float,float,float, float,float,float, float]) # line 2
00354             data.append(sline)
00355             self.i+=2
00356 
00357         return data
00358 
00359     def getQuadStress(self):
00360         (iSubcase,transient,dataCode) = self.getQuadHeader(2,False,33)
00361         dataCode['tableName']  = 'OES1X'
00362         data = self.readTriStress(['CQUAD4'])
00363         if iSubcase in self.plateStress:
00364             self.plateStress[iSubcase].addF06Data(data,transient)
00365         else:
00366             isSort1 = True
00367             assert 'nonlinearFactor' in dataCode
00368             self.plateStress[iSubcase] = PlateStressObject(dataCode,isSort1,iSubcase,transient)
00369             self.plateStress[iSubcase].addF06Data(data,transient)
00370         self.iSubcases.append(iSubcase)
00371 
00372     def getQuadStrains(self):
00373         (iSubcase,transient,dataCode) = self.getQuadHeader(2,True,33)
00374         dataCode['tableName']  = 'OSTR1X'
00375         data = self.readTriStress(['CQUAD4'])
00376         if iSubcase in self.plateStrain:
00377             self.plateStrain[iSubcase].addF06Data(data,transient)
00378         else:
00379             isSort1 = True
00380             self.plateStrain[iSubcase] = PlateStrainObject(dataCode,isSort1,iSubcase,transient)
00381             self.plateStrain[iSubcase].addF06Data(data,transient)
00382         self.iSubcases.append(iSubcase)
00383 
00384     def getQuadStressBilinear(self):
00385         """
00386                              S T R E S S E S   I N   Q U A D R I L A T E R A L   E L E M E N T S   ( Q U A D 4 )        OPTION = BILIN
00387 
00388         ELEMENT              FIBER            STRESSES IN ELEMENT COORD SYSTEM         PRINCIPAL STRESSES (ZERO SHEAR)
00389           ID      GRID-ID   DISTANCE        NORMAL-X      NORMAL-Y      SHEAR-XY      ANGLE        MAJOR         MINOR       VON MISES
00390               6    CEN/4  -1.250000E-01  -4.278394E+02  8.021165E+03 -1.550089E+02   -88.9493   8.024007E+03 -4.306823E+02  8.247786E+03
00391                            1.250000E-01   5.406062E+02  1.201854E+04 -4.174177E+01   -89.7916   1.201869E+04  5.404544E+02  1.175778E+04
00392 
00393                        4  -1.250000E-01  -8.871141E+02  7.576036E+03 -1.550089E+02   -88.9511   7.578874E+03 -8.899523E+02  8.060780E+03
00394                            1.250000E-01  -8.924081E+01  1.187899E+04 -4.174177E+01   -89.8002   1.187913E+04 -8.938638E+01  1.192408E+04
00395         """
00396         (iSubcase,transient,dataCode) = self.getQuadHeader(3,False,144)
00397         dataCode['tableName']  = 'OES1X',
00398         data = self.readQuadBilinear()
00399         if iSubcase in self.plateStress:
00400             self.plateStress[iSubcase].addF06Data(data,transient)
00401         else:
00402             isSort1 = True
00403             assert 'nonlinearFactor' in dataCode
00404             self.plateStress[iSubcase] = PlateStressObject(dataCode,isSort1,iSubcase,transient)
00405             self.plateStress[iSubcase].addF06Data(data,transient)
00406         self.iSubcases.append(iSubcase)
00407 
00408     def getQuadHeader(self, nHeaderLines, isStrain, elementNumber):
00409         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00410         headers = self.skip(nHeaderLines)
00411         #print "headers = %s" %(headers)
00412         
00413         isFiberDistance = False
00414         isMaxShear = False  # Von Mises/Max Shear
00415         if 'DISTANCE' in headers:
00416             isFiberDistance = True
00417         if 'MAX SHEAR' in headers:
00418             isMaxShear = True
00419         (stressBits,sCode) = self.makeStressBits(isFiberDistance,isMaxShear,isStrain)
00420         dataCode = {'log':self.log, 'analysisCode':analysisCode, 
00421                     'deviceCode':1, 'tableCode':5, 'sortCode':0,
00422                     'sortBits':[0,0,0], 'numWide':8, 'sCode':sCode,
00423                     'stressBits':stressBits, 'formatCode':1,
00424                     'elementName':'CQUAD4', 'elementType':elementNumber,
00425                     'nonlinearFactor': dt,
00426                     }
00427         return (iSubcase,transient,dataCode)
00428 
00429     def readQuadBilinear(self):
00430         data = []
00431         while 1:
00432             if 1: # CEN/4
00433                 line = self.infile.readline()[1:].strip().split()
00434                 if 'PAGE' in line:
00435                     return data
00436                 sline = self.parseLine(line,[int,str,float, float,float,float, float,float,float, float]) # line 1
00437                 sline = ['CQUAD4']+sline
00438                 #data.append(sline)
00439                 line = self.infile.readline()[1:].strip().split()
00440                 sline += self.parseLine(line,[        float, float,float,float, float,float,float, float]) # line 2
00441                 data.append(sline)
00442                 line = self.infile.readline() # blank line
00443                 self.i+=3
00444 
00445             for i in xrange(4):
00446                 line = self.infile.readline()[1:].strip().split()
00447                 sline = self.parseLine(line,[int,float, float,float,float, float,float,float, float]) # line 1
00448                 #data.append(sline)
00449                 line = self.infile.readline()[1:].strip().split()
00450                 sline += self.parseLine(line,[    float, float,float,float, float,float,float, float]) # line 2
00451                 data.append(sline)
00452                 line = self.infile.readline() # blank line
00453                 self.i+=3
00454 
00455         return data
00456 
00457     def getSolidStressHexa(self):
00458         return self.readSolidStress('CHEXA', 8)
00459     def getSolidStressPenta(self):
00460         return self.readSolidStress('CPENTA', 6)
00461     def getSolidStressTetra(self):
00462         return self.readSolidStress('CTETRA', 4)
00463 
00464     def getSolidStrainHexa(self):
00465         return self.readSolidStrain('CHEXA', 8)
00466     def getSolidStrainPenta(self):
00467         return self.readSolidStrain('CPENTA', 6)
00468     def getSolidStrainTetra(self):
00469         return self.readSolidStrain('CTETRA', 4)
00470 
00471     def readSolidStress(self,eType,n):
00472         (iSubcase,transient,dataCode) = self.getSolidHeader(eType,n,False)
00473         dataCode['tableName']  = 'OES1X'
00474     
00475         data = self.read3DStress(eType,n)
00476         if iSubcase in self.solidStress:
00477             self.solidStress[iSubcase].addF06Data(data,transient)
00478         else:
00479             isSort1 = True
00480             self.solidStress[iSubcase] = SolidStressObject(dataCode,isSort1,iSubcase,transient)
00481             self.solidStress[iSubcase].addF06Data(data,transient)
00482         self.iSubcases.append(iSubcase)
00483 
00484     def readSolidStrain(self,eType,n):
00485         (iSubcase,transient,dataCode) = self.getSolidHeader(eType,n,True)
00486         dataCode['tableName']  = 'OSTR1X'
00487     
00488         data = self.read3DStress(eType,n)
00489         if iSubcase in self.solidStrain:
00490             self.solidStrain[iSubcase].addF06Data(data,transient)
00491         else:
00492             isSort1 = True
00493             self.solidStrain[iSubcase] = SolidStrainObject(dataCode,isSort1,iSubcase,transient)
00494             self.solidStrain[iSubcase].addF06Data(data,transient)
00495         self.iSubcases.append(iSubcase)
00496 
00497     def getSolidHeader(self,eType,n,isStrain):
00498         """
00499         analysisCode = 1 (Statics)
00500         deviceCode   = 1 (Print)
00501         tableCode    = 5 (Stress/Strain)
00502         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00503         formatCode   = 1 (Real)
00504         sCode        = 0 (Stress/Strain)
00505         numWide      = 8 (???)
00506         """
00507         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00508         headers = self.skip(2)
00509         #print "headers = %s" %(headers)
00510 
00511         isMaxShear = True
00512         if 'VON MISES' in headers:
00513             isMaxShear = False
00514             
00515         (stressBits,sCode) = self.makeStressBits(isMaxShear=False,isStrain=isStrain,isRodOrSolid=True)
00516         dataCode = {'log':self.log, 'analysisCode':1, 'deviceCode':1,
00517                     'tableCode':5, 'sortCode':0, 'sortBits':[0,0,0],
00518                     'numWide':8, 'elementName':eType, 'formatCode':1,
00519                     'sCode':sCode, 'stressBits':stressBits,
00520                     'nonlinearFactor': dt}
00521         return (iSubcase,transient,dataCode)
00522 
00523     def read3DStress(self,eType,n):
00524         data = []
00525         while 1:
00526             line = self.infile.readline().rstrip('\n\r') #[1:]
00527                     #              CENTER         X          #          XY             #        A         #
00528             sline = [line[1:17],line[17:24],line[24:28],line[28:43],line[43:47],line[47:63],line[63:66],line[66:80],  line[80:83],line[83:88],line[88:93],line[93:98],line[99:113],line[113:130]]
00529             sline = [s.strip() for s in sline]
00530             if 'PAGE' in line:
00531                 break
00532             elif '' is not sline[0]:
00533                 sline = [eType]+sline
00534             data.append(sline)
00535         ###
00536         return data
00537 
00538     def makeStressBits(self,isFiberDistance=False,isMaxShear=True,isStrain=True,isRodOrSolid=False):
00539         #print "isMaxShear=%s isFiberDistance=%s" %(isMaxShear,isFiberDistance)
00540         
00541        #code = (isVonMises,isFiberCurvatur,isStress,isNotRod)
00542         code = (isMaxShear, isFiberDistance, isStrain, isRodOrSolid)
00543         mapper = {
00544                   # element coordinate system (no material support)
00545                   (True, False,False, True): ([0,0,0,0,0], 0),  # 0,  rod/csolid
00546                   (False,False,False, True): ([0,0,0,0,1], 1),  # 1,  rod/csolid
00547                   (True, False, True,False): ([0,1,0,1,0], 10), # 10
00548                   (False,False, True,False): ([0,1,0,1,1], 11), # 11
00549                   (True,  True, True,False): ([0,1,1,1,0], 14), # 14
00550                   (False, True, True,False): ([0,1,1,1,1], 15), # 15
00551 
00552                   (True, False,False,False): ([0,0,0,0,0], 0),  # 0,  composite
00553                   (False, True,False,False): ([0,0,0,0,1], 1), # cquad4 bilinear ??? why do i need this...
00554                  }
00555         (stressBits,sCode) = mapper[code]
00556 
00557         #if isMaxShear==False:
00558         #    stressBits[4] = 1 # Von Mises
00559         #if isStrain:
00560         #    #stressBits[1] = stressBits[3] = 1 # Strain
00561         #    stressBits[1] = stressBits[3] = 1 # Strain
00562         #if isFiberDistance:
00563         #    stressBits[2] = 1 # FiberDistance
00564         #print stressBits
00565         #sCode = 0
00566         #for i,bit in enumerate(stressBits):
00567         #    sCode += bit*2**i
00568         return (stressBits, sCode)
00569         
 All Classes Namespaces Files Functions Variables