pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
f06.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 import os
00026 import sys
00027 from itertools import izip
00028 
00029 from pyNastran.general.general import printBadPath
00030 
00031 #ComplexEigenvalues,strainEnergyDensity,TemperatureGradientObject
00032 from pyNastran.op2.tables.oug.oug_eigenvectors import EigenVectorObject #,ComplexEigenVectorObject
00033 from pyNastran.op2.tables.lama_eigenvalues.lama_objects import RealEigenvalues,ComplexEigenvalues
00034 
00035 from pyNastran.f06.tables.oes import OES  # OES
00036 from pyNastran.f06.tables.oug import OUG  # OUG
00037 from pyNastran.f06.tables.oqg import OQG  # OUG
00038 from pyNastran.f06.f06_classes import MaxDisplacement # classes not in op2
00039 from pyNastran.f06.f06Writer import F06Writer
00040 
00041 class EndOfFileError(Exception):
00042     pass
00043 
00044 class F06(OES,OUG,OQG,F06Writer):
00045     def __init__(self, f06FileName, debug=False, log=None):
00046         """
00047         Initializes the F06 object
00048         @param f06FileName
00049           the file to be parsed
00050         @param makeGeom
00051           reads the BDF tables (default=False)
00052         @param debug
00053           prints data about how the F06 was parsed (default=False)
00054         @param log
00055           a logging object to write debug messages to (@see import logging)
00056         """
00057         self.f06FileName = f06FileName
00058         if not os.path.exists(self.f06FileName):
00059             msg = 'cant find F06FileName=|%s|\n%s' %(self.f06FileName,printBadPath(self.f06FileName))
00060             raise RuntimeError(msg)
00061         self.infile = open(self.f06FileName, 'r')
00062         self.__initAlt__(debug,log)
00063 
00064         self.lineMarkerMap = {
00065           'R E A L   E I G E N V E C T O R   N O':self.getRealEigenvectors,
00066         }
00067         self.markerMap = {
00068           #'N A S T R A N    F I L E    A N D    S Y S T E M    P A R A M E T E R    E C H O':self.fileSystem,
00069           #'N A S T R A N    E X E C U T I V E    C O N T R O L    E C H O':self.executiveControl,
00070           #'C A S E    C O N T R O L    E C H O ':self.caseControl,
00071           #'M O D E L   S U M M A R Y':self.summary,
00072           
00073           #'E L E M E N T   G E O M E T R Y   T E S T   R E S U L T S   S U M M A R Y'
00074           'O U T P U T   F R O M   G R I D   P O I N T   W E I G H T   G E N E R A T O R':self.getGridWeight,
00075           #'OLOAD    RESULTANT':self.oload,
00076           #'MAXIMUM  SPCFORCES':self.getMaxSpcForces,
00077           #'MAXIMUM  DISPLACEMENTS': self.getMaxDisplacements,
00078           #'MAXIMUM  APPLIED LOADS': self.getMaxAppliedLoads,
00079           #'G R I D   P O I N T   S I N G U L A R I T Y   T A B L E': self.gridPointSingularities,
00080 
00081 
00082 #------------------------
00083 #    N O N - D I M E N S I O N A L   S T A B I L I T Y   A N D   C O N T R O L   D E R I V A T I V E   C O E F F I C I E N T S
00084 #          N O N - D I M E N S I O N A L    H I N G E    M O M E N T    D E R I V A T I V E   C O E F F I C I E N T S
00085 #                               A E R O S T A T I C   D A T A   R E C O V E R Y   O U T P U T   T A B L E S
00086 #                              S T R U C T U R A L   M O N I T O R   P O I N T   I N T E G R A T E D   L O A D S
00087 #------------------------
00088 #                                    R O T O R   D Y N A M I C S   S U M M A R Y
00089 #                              R O T O R   D Y N A M I C S   M A S S   S U M M A R Y
00090 #                           E I G E N V A L U E  A N A L Y S I S   S U M M A R Y   (COMPLEX LANCZOS METHOD) 
00091 #------------------------
00092 
00093           'R E A L   E I G E N V A L U E S':self.getRealEigenvalues,
00094           #'C O M P L E X   E I G E N V A L U E   S U M M A R Y':self.getComplexEigenvalues,
00095           'E L E M E N T   S T R A I N   E N E R G I E S':self.getElementStrainEnergies,
00096           'D I S P L A C E M E N T   V E C T O R':self.getDisplacement,
00097           'C O M P L E X   D I S P L A C E M E N T   V E C T O R':self.getComplexDisplacement,
00098           'F O R C E S   O F   S I N G L E - P O I N T   C O N S T R A I N T':self.getSpcForces,
00099           'F O R C E S   O F   M U L T I P O I N T   C O N S T R A I N T': self.getMpcForces,
00100           #'G R I D   P O I N T   F O R C E   B A L A N C E':self.getGridPointForces,
00101 
00102           '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 )':self.getBarStress,
00103           '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 )':self.getRodStress,
00104 
00105           '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 )': self.getTriStress,
00106           '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 )': self.getQuadStress,
00107           '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': self.getQuadStressBilinear,
00108           '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 )': self.getQuadCompositeStress,
00109 
00110           'S T R E S S E S   I N    T E T R A H E D R O N   S O L I D   E L E M E N T S   ( C T E T R A )':self.getSolidStressTetra,
00111           'S T R E S S E S   I N   H E X A H E D R O N   S O L I D   E L E M E N T S   ( H E X A )':self.getSolidStressHexa,
00112           'S T R E S S E S   I N   P E N T A H E D R O N   S O L I D   E L E M E N T S   ( P E N T A )':self.getSolidStressPenta,
00113 
00114           'S T R A I N S    I N   B A R   E L E M E N T S          ( C B A R )':self.getBarStrain,
00115           'S T R A I N S   I N   R O D   E L E M E N T S      ( C R O D )':self.getRodStrain,
00116 
00117           'S T R A I N 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 )':self.getQuadStrains,
00118           'S T R A I N 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 )':self.getTriStrain,
00119 
00120           'S T R A I N S   I N    T E T R A H E D R O N   S O L I D   E L E M E N T S   ( C T E T R A )':self.getSolidStrainTetra,
00121           'S T R A I N S   I N   H E X A H E D R O N   S O L I D   E L E M E N T S   ( H E X A )':self.getSolidStrainHexa,
00122           'S T R A I N S   I N   P E N T A H E D R O N   S O L I D   E L E M E N T S   ( P E N T A )':self.getSolidStrainPenta,
00123 
00124           'T E M P E R A T U R E   V E C T O R':self.getTemperatureVector,
00125           'F I N I T E   E L E M E N T   T E M P E R A T U R E   G R A D I E N T S   A N D   F L U X E S':self.getTempGradientsFluxes,
00126 
00127           #'* * * END OF JOB * * *': self.end(),
00128          }
00129         self.markers = self.markerMap.keys()
00130 
00131     def __initAlt__(self,debug=False,log=None):
00132         self.i = 0
00133         self.storedLines = []
00134 
00135         self.displacementsPSD = {}        # random
00136         self.displacementsATO = {}        # random
00137         self.displacementsRMS = {}        # random
00138         self.displacementsCRM = {}        # random
00139         self.displacementsNO  = {}        # random
00140         self.scaledDisplacements = {}     # tCode=1 thermal=8
00141 
00142         #-----------------------------------
00143         self.velocities = {}
00144         self.accelerations = {}
00145         self.eigenvalues = {}
00146         self.eigenvectors = {}
00147         
00148         self.thermalLoadVectors = {}
00149         self.forceVectors = {}
00150         self.barForces = {}
00151 
00152         self.beamForces = {}
00153         self.springForces = {}
00154         self.damperForces = {}
00155         self.solidPressureForces = {}
00156         
00157         self.rodStrain = {}
00158         self.nonlinearRodStress = {}
00159         self.barStrain = {}
00160         self.plateStrain = {}
00161         self.nonlinearPlateStrain = {}
00162         self.compositePlateStrain = {}
00163         self.solidStrain = {}
00164         self.beamStrain = {}
00165         self.ctriaxStrain = {}
00166         self.hyperelasticPlateStress = {}
00167 
00168         self.rodStress = {}
00169         self.nonlinearRodStrain = {}
00170         self.barStress = {}
00171         self.plateStress = {}
00172         self.nonlinearPlateStress = {}
00173         self.compositePlateStress = {}
00174         self.solidStress = {}
00175         self.beamStress = {}
00176         self.ctriaxStress = {}
00177         self.hyperelasticPlateStrain = {}
00178         
00179         
00180         # beam, shear...not done
00181         self.shearStrain = {}
00182         self.shearStress = {}
00183         
00184         
00185         self.gridPointStresses = {}
00186         self.gridPointVolumeStresses = {}
00187         self.gridPointForces = {}
00188         #-----------------------------------
00189 
00190         self.iSubcases = []
00191         self.temperatureGrad = {}
00192         
00193         self.iSubcaseNameMap = {}
00194         self.loadVectors = {}
00195         self.gridPointForces = {}
00196 
00197         OES.__init__(self)
00198         OQG.__init__(self)
00199         OUG.__init__(self)
00200         
00201         ## the TITLE in the Case Control Deck
00202         self.Title = ''
00203         self.startLog(log,debug)
00204 
00205     def startLog(self,log=None,debug=False):
00206         """
00207         Sets up a dummy logger if one is not provided
00208         @param self the object pointer
00209         @param log a python logging object
00210         @param debug adds debug messages (True/False)
00211         """
00212         if log is None:
00213             from pyNastran.general.logger import dummyLogger
00214             if debug:
00215                 word = 'debug'
00216             else:
00217                 word = 'info'
00218             loggerObj = dummyLogger()
00219             log = loggerObj.startLog(word) # or info
00220         self.log = log
00221 
00222     def getGridPointSingularities(self):  # @todo not done
00223         """
00224                     G R I D   P O I N T   S I N G U L A R I T Y   T A B L E
00225         POINT    TYPE   FAILED      STIFFNESS       OLD USET           NEW USET
00226          ID            DIRECTION      RATIO     EXCLUSIVE  UNION   EXCLUSIVE  UNION
00227           1        G      4         0.00E+00          B        F         SB       S    *
00228           1        G      5         0.00E+00          B        F         SB       S    *
00229         """
00230         pass
00231 
00232     def getMaxSpcForces(self):  # @todo not done
00233         headers = self.skip(2)
00234         #print "headers = %s" %(headers)
00235         data = self.readTable([int,float,float,float,float,float,float])
00236         #print "max SPC Forces   ",data
00237         #self.disp[iSubcase] = DisplacementObject(iSubcase,data)
00238         #print self.disp[iSubcase]
00239 
00240     def getMaxDisplacements(self):  # @todo not done
00241         headers = self.skip(2)
00242         #print "headers = %s" %(headers)
00243         data = self.readTable([int,float,float,float,float,float,float])
00244         #print "max Displacements",data
00245         disp = MaxDisplacement(data)
00246         #print disp.writeF06()
00247         #self.disp[iSubcase] = DisplacementObject(iSubcase,data)
00248         #print self.disp[iSubcase]
00249     
00250     def getMaxAppliedLoads(self):  # @todo not done
00251         headers = self.skip(2)
00252         #print "headers = %s" %(headers)
00253         data = self.readTable([int,float,float,float,float,float,float])
00254         #print "max Applied Loads",data
00255         #self.disp[iSubcase] = DisplacementObject(iSubcase,data)
00256         #print self.disp[iSubcase]
00257 
00258     def getGridWeight(self):  # @todo not done
00259         line = ''
00260         while 'PAGE' not in line:
00261             line = self.infile.readline()[1:]
00262             self.i+=1
00263         ###
00264 
00265     def readSubcaseNameID(self):
00266         subcaseName = self.storedLines[-3].strip()
00267         #print ''.join(self.storedLines)
00268         self.Title = subcaseName #'no title'
00269         #print "Title = ",self.Title
00270 
00271         #print "subcaseLine = |%r|" %(subcaseName)
00272         if subcaseName=='':
00273             iSubcase = 1
00274         else:
00275             iSubcase   = self.storedLines[-2].strip()[1:]
00276             if iSubcase=='': # no subcase specified
00277                 iSubcase=1
00278             else:
00279                 iSubcase = int(iSubcase.strip('SUBCASE '))
00280             ###
00281             #assert isinstance(iSubcase,int),'iSubcase=|%r|' %(iSubcase)
00282             #print "subcaseName=%s iSubcase=%s" %(subcaseName,iSubcase)
00283         ###
00284         self.iSubcaseNameMap[iSubcase] = [subcaseName,'SUBCASE %s' %(iSubcase)]
00285         transient   = self.storedLines[-1].strip()
00286         isSort1 = False
00287         if transient:
00288             transWord,transValue = transient.split('=')
00289             transWord = transWord.strip()
00290             transValue = float(transValue)
00291             transient = [transWord,transValue]
00292             
00293             if transWord=='LOAD STEP': # nonlinear statics
00294                 analysisCode = 10
00295             elif transWord=='TIME STEP': ## @todo check name
00296                 analysisCode = 6
00297             elif transWord=='EIGENVALUE': # normal modes
00298                 analysisCode = 2
00299             elif transWord=='FREQ': ## @todo check name
00300                 analysisCode = 5
00301             elif transWord=='POINT-ID':
00302                 isSort1 = True
00303                 analysisCode = None
00304             else:
00305                 raise NotImplementedError('transientWord=|%r| is not supported...' %(transWord))
00306             ###
00307         else:
00308             transient = None
00309             analysisCode = 1
00310 
00311         dt = None
00312         if transient is not None:
00313             dt = transient[1]
00314         return (subcaseName,iSubcase,transient,dt,analysisCode,isSort1)
00315 
00316     def getRealEigenvalues(self):
00317         """
00318                                                    R E A L   E I G E N V A L U E S
00319          MODE    EXTRACTION      EIGENVALUE            RADIANS             CYCLES            GENERALIZED         GENERALIZED
00320           NO.       ORDER                                                                       MASS              STIFFNESS
00321               1         1        6.158494E+07        7.847607E+03        1.248985E+03        1.000000E+00        6.158494E+07
00322         """
00323         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00324         
00325         headers = self.skip(2)
00326         data = self.readTable([int, int, float, float, float, float, float])
00327         
00328         if iSubcase in self.eigenvalues:
00329             self.eigenvalues[iSubcase].addF06Data(data)
00330         else:
00331             self.eigenvalues[iSubcase] = RealEigenvalues(iSubcase)
00332             self.eigenvalues[iSubcase].addF06Data(data)
00333         self.iSubcases.append(iSubcase)
00334 
00335     def getComplexEigenvalues(self):
00336         """
00337                                C O M P L E X   E I G E N V A L U E   S U M M A R Y
00338         ROOT     EXTRACTION                  EIGENVALUE                     FREQUENCY              DAMPING
00339          NO.        ORDER             (REAL)           (IMAG)                (CYCLES)            COEFFICIENT
00340              1           6          0.0              6.324555E+01          1.006584E+01          0.0
00341              2           5          0.0              6.324555E+01          1.006584E+01          0.0
00342         """
00343         #(subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00344         iSubcase = 1  # @todo fix this...
00345 
00346         headers = self.skip(2)
00347         data = self.readTable([int,int,float,float, float,float])
00348 
00349         if iSubcase in self.eigenvalues:
00350             self.eigenvalues[iSubcase].addF06Data(data)
00351         else:
00352             isSort1 = True
00353             self.eigenvalues[iSubcase] = ComplexEigenvalues(iSubcase)
00354             self.eigenvalues[iSubcase].addF06Data(data)
00355         self.iSubcases.append(iSubcase)
00356 
00357     def getRealEigenvectors(self,marker):
00358         """
00359                                                                                                                SUBCASE 1
00360         EIGENVALUE =  6.158494E+07
00361             CYCLES =  1.248985E+03         R E A L   E I G E N V E C T O R   N O .          1
00362         
00363         POINT ID.   TYPE          T1             T2             T3             R1             R2             R3
00364                1      G      2.547245E-17  -6.388945E-16   2.292728E+00  -1.076928E-15   2.579163E-17   0.0
00365             2002      G     -6.382321E-17  -1.556607E-15   3.242408E+00  -6.530917E-16   1.747180E-17   0.0
00366         
00367         analysisCode = 2 (Normal modes)
00368         tableCode    = 7 (Eigenvector)
00369 
00370         deviceCode   = 1 (Print)
00371         sortCode     = 0 (Sort2,Real,Sorted Results) => sortBits = [0,0,0]
00372         formatCode   = 1 (Real)
00373         #sCode        = 0 (Stress)
00374         numWide      = 8 (???)
00375         """
00376         cycle,iMode = marker.strip().split('R E A L   E I G E N V E C T O R   N O .')
00377         iMode = int(iMode)
00378 
00379         cycles = cycle.strip().split('=')
00380         #print smarker
00381         assert 'CYCLES'==cycles[0].strip(),'marker=%s' %(marker)
00382         cycle = float(cycles[1])
00383 
00384         #print "marker = |%s|" %(marker)
00385         #subcaseName = '???'
00386         #print self.storedLines
00387         #iSubcase = self.storedLines[-2].strip()[1:]
00388         #iSubcase = int(iSubcase.strip('SUBCASE '))
00389         #print "subcaseName=%s iSubcase=%s" %(subcaseName,iSubcase)
00390         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00391         headers = self.skip(2)
00392         
00393         dataCode = {'log':self.log, 'analysisCode':analysisCode,
00394                     'deviceCode':1, 'tableCode':7, 'sortCode':0,
00395                     'sortBits':[0, 0, 0],'numWide':8, 'formatCode':1,
00396                     'mode':iMode, 'eigr':transient[1], 'modeCycle':cycle,
00397                     'dataNames':['mode', 'eigr', 'modeCycle'],
00398                     'name':'mode', 'tableName':'OUGV1',
00399                     'nonlinearFactor':iMode,
00400                     #'sCode':0,
00401                     #'elementName':'CBAR','elementType':34,'stressBits':stressBits,
00402                     }
00403 
00404         data = self.readTable([int,str,float,float,float,float,float,float])
00405 
00406         if iSubcase in self.eigenvectors:
00407             self.eigenvectors[iSubcase].readF06Data(dataCode,data)
00408         else:
00409             isSort1 = True
00410             self.eigenvectors[iSubcase] = EigenVectorObject(dataCode, isSort1,
00411                                                             iSubcase,iMode)
00412             self.eigenvectors[iSubcase].readF06Data(dataCode,data)
00413         ###
00414     
00415     def getElementStrainEnergies(self):
00416         """
00417         EIGENVALUE = -3.741384E-04
00418         CYCLES =  3.078479E-03
00419                                            E L E M E N T   S T R A I N   E N E R G I E S
00420  
00421                 ELEMENT-TYPE = QUAD4               * TOTAL ENERGY OF ALL ELEMENTS IN PROBLEM     =  -1.188367E-05
00422                    MODE               1            * TOTAL ENERGY OF ALL ELEMENTS IN SET      -1 =  -1.188367E-05
00423  
00424                                     ELEMENT-ID          STRAIN-ENERGY           PERCENT OF TOTAL    STRAIN-ENERGY-DENSITY
00425                                              1         -5.410134E-08                -0.0929             -4.328107E-05
00426                                              2         -3.301516E-09                -0.0057             -2.641213E-06
00427         """
00428         iSubcase = 1 ## @todo not correct
00429         cycles = self.storedLines[-1][1:].strip()
00430         cycles = float(cycles.split('=')[1])
00431 
00432         eigenvalue = self.storedLines[-2][1:].strip()
00433         eigenvalue = float(eigenvalue.split('=')[1])
00434         #print "eigenvalue=%s cycle=%s" %(eigenvalue,cycles)
00435 
00436         eTypeLine = self.skip(2)[1:]
00437         modeLine  = self.skip(1)[1:]
00438         eType=eTypeLine[30:40];  totalEnergy1=eTypeLine[99:114]
00439         iMode=modeLine[24:40];   totalEnergy2=modeLine[99:114]
00440         #print "eType=%s totalEnergy1=|%s|" %(eType,totalEnergy1)
00441         #print "iMode=%s totalEnergy2=|%s|" %(iMode,totalEnergy2)
00442         headers = self.skip(2)
00443 
00444         data = []
00445         while 1:
00446             line = self.infile.readline()[1:].rstrip('\r\n ')
00447             self.i+=1
00448             if 'PAGE' in line:
00449                 break
00450             sline = line.strip().split()
00451             if sline==[]:
00452                 break
00453             #print sline
00454             eid = int(sline[0])
00455             strainEnergy = float(sline[1])
00456             percentTotal = float(sline[2])
00457             strainEnergyDensity = float(sline[3])
00458             out = (eid,strainEnergy,percentTotal,strainEnergyDensity)
00459             data.append(out)
00460         ###
00461 
00462         if sline==[]:
00463             line = self.infile.readline()[1:].rstrip('\r\n ')
00464             self.i+=1
00465             #print line
00466 
00467         return
00468         if iSubcase in self.iSubcases:
00469             self.strainEnergyDensity[iSubcase].readF06Data(data,transient)
00470         else:
00471             sed = strainEnergyDensity(data,transient)
00472             sed.readF06Data(data,transient)
00473             self.strainEnergyDensity[iSubcase] = sed
00474         ###
00475 
00476     def getTempGradientsFluxes(self):
00477         (subcaseName,iSubcase,transient,dt,analysisCode,isSort1) = self.readSubcaseNameID()
00478         #print transient
00479         headers = self.skip(2)
00480         #print "headers = %s" %(headers)
00481         data = self.readGradientFluxesTable()
00482         #print data
00483         return
00484         if iSubcase in self.temperatureGrad:
00485             self.temperatureGrad[iSubcase].addData(data)
00486         else:
00487             self.temperatureGrad[iSubcase] = TemperatureGradientObject(iSubcase,data)
00488         self.iSubcases.append(iSubcase)
00489 
00490     def readGradientFluxesTable(self):
00491         data = []
00492         Format = [int,str,float,float,float, float,float,float]
00493         while 1:
00494             line = self.infile.readline()[1:].rstrip('\r\n ')
00495             self.i+=1
00496             if 'PAGE' in line:
00497                 return data
00498             sline = [line[0:15],line[15:24].strip(),line[24:44],line[44:61],line[61:78],line[78:95],line[95:112],line[112:129]]
00499             sline = self.parseLineGradientsFluxes(sline,Format)
00500             data.append(sline)
00501         return data
00502 
00503     def parseLineGradientsFluxes(self,sline,Format):
00504         out = []
00505         for entry,iFormat in izip(sline,Format):
00506             if entry.strip() is '':
00507                 out.append(0.0)
00508             else:
00509                 #print "sline=|%r|\n entry=|%r| format=%r" %(sline,entry,iFormat)
00510                 entry2 = iFormat(entry)
00511                 out.append(entry2)
00512             ###
00513         return out
00514     
00515     def readTable(self,Format):
00516         """
00517         reads displacement, spc/mpc forces
00518         @param self the object pointer
00519         @param Format @see parseLine
00520         """
00521         sline = True
00522         data = []
00523         while sline:
00524             sline = self.infile.readline()[1:].strip().split()
00525             self.i+=1
00526             if 'PAGE' in sline:
00527                 return data
00528             sline = self.parseLine(sline,Format)
00529             if sline is None:
00530                 return data
00531             data.append(sline)
00532         return data
00533     
00534     def parseLine(self,sline,Format):
00535         """
00536         @param self the object pointer
00537         @param sline list of strings (split line)
00538         @param Format list of types [int,str,float,float,float] that maps to sline
00539         """
00540         out = []
00541         for entry,iFormat in izip(sline,Format):
00542             try:
00543                 entry2 = iFormat(entry)
00544             except:
00545                 #print "sline=|%s|\n entry=|%s| format=%s" %(sline,entry,iFormat)
00546                 return None
00547             out.append(entry2)
00548         return out
00549         
00550     def parseLineBlanks(self,sline,Format):
00551         """allows blanks"""
00552         out = []
00553         for entry,iFormat in izip(sline,Format):
00554             if entry.strip():
00555                 entry2 = iFormat(entry)
00556             else:
00557                 entry2 = None
00558                 #print "sline=|%s|\n entry=|%s| format=%s" %(sline,entry,iFormat)
00559             out.append(entry2)
00560         return out
00561     
00562     def readF06(self):
00563         """
00564         Reads the F06 file
00565         @param self the object pointer
00566         """
00567         #print "reading..."
00568         blank = 0
00569         while 1:
00570             #if self.i%1000==0:
00571                 #print "i=%i" %(self.i)
00572             line = self.infile.readline()
00573             marker = line[1:].strip()
00574             
00575             #print "marker = %s" %(marker)
00576             if marker in self.markers:
00577                 blank = 0
00578                 #print "\n*marker = %s" %(marker)
00579                 self.markerMap[marker]()
00580                 self.storedLines = []
00581                 #print "i=%i" %(self.i)
00582             elif 'R E A L   E I G E N V E C T O R   N O' in marker:
00583                 blank = 0
00584                 #print "\n*marker = %s" %(marker)
00585                 self.lineMarkerMap['R E A L   E I G E N V E C T O R   N O'](marker)
00586                 self.storedLines = []
00587             elif marker=='':
00588                 blank +=1
00589                 if blank==20:
00590                     break
00591             elif self.isMarker(marker): # marker with space in it (e.g. Model Summary)
00592                 print("***marker = |%s|" %(marker))
00593                 
00594             else:
00595                 blank = 0
00596             ###
00597             self.storedLines.append(line)
00598             self.i+=1
00599         #print "i=%i" %(self.i)
00600         self.infile.close()
00601         self.processF06()
00602 
00603     def processF06(self):
00604         #data = [self.disp,self.SpcForces,self.stress,self.isoStress,self.barStress,self.solidStress,self.temperature]
00605         dataPack = [self.solidStress]
00606         for dataSet in dataPack:
00607             for key,data in dataSet.iteritems():
00608                 data.processF06Data()
00609         
00610     def isMarker(self,marker):
00611         """returns True if the word follows the 'N A S T R A N   P A T T E R N'"""
00612         marker = marker.strip().split('$')[0].strip()
00613 
00614         if len(marker)<2 or marker=='* * * * * * * * * * * * * * * * * * * *':
00615             return False
00616         for i,char in enumerate(marker):
00617             #print "i=%s i%%2=%s char=%s" %(i,i%2,char)
00618             if i%2==1 and ' ' is not char:
00619                 return False
00620             elif i%2==0 and ' '==char:
00621                 return False
00622             ###
00623         ###
00624         return True
00625 
00626     def skip(self,iskip):
00627         for i in xrange(iskip-1):
00628             self.infile.readline()
00629         self.i += iskip
00630         return self.infile.readline()
00631     
00632     def printResults(self):
00633         msg = ''
00634         data = [self.displacements,self.spcForces,self.mpcForces,self.temperatures,
00635                 self.eigenvalues,self.eigenvectors,
00636                 self.rodStress,self.rodStrain,
00637                 self.barStress,self.barStrain,
00638                 self.plateStress,self.plateStrain,
00639                 self.compositePlateStress,self.compositePlateStrain,
00640                ]
00641 
00642         self.iSubcases = list(set(self.iSubcases))
00643         for iSubcase in self.iSubcases:
00644             for result in data:
00645                 if iSubcase in result:
00646                     msg += str(result[iSubcase])
00647                 ###
00648             ###
00649         return msg
00650 
00651 if __name__=='__main__':
00652     f06Name = sys.argv[1]
00653     model = f06Name.split('.f06')[0]
00654     f06 = F06(f06Name)
00655     f06.readF06()
00656 
00657     f06.writeF06(model+'f06.out')
00658     f06.printResults()
00659     print("done...")
00660 
 All Classes Namespaces Files Functions Variables