pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
nastranIO.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 # pylint: disable=C0103,C0111,E1101
00026 
00027 #VTK_TRIANGLE = 5
00028 #VTK_QUADRATIC_TRIANGLE = 22
00029 
00030 #VTK_QUAD = 9
00031 #VTK_QUADRATIC_QUAD = 23
00032 
00033 #VTK_TETRA = 10
00034 #VTK_QUADRATIC_TETRA = 24
00035 
00036 #VTK_WEDGE = 13
00037 #VTK_QUADRATIC_WEDGE = 26
00038 
00039 #VTK_HEXAHEDRON = 12
00040 #VTK_QUADRATIC_HEXAHEDRON = 25
00041 
00042 
00043 from numpy import zeros
00044 
00045 import vtk
00046 from vtk import (vtkTriangle, vtkQuad, vtkTetra, vtkWedge, vtkHexahedron,
00047                  vtkQuadraticTriangle, vtkQuadraticQuad, vtkQuadraticTetra,
00048                  vtkQuadraticWedge, vtkQuadraticHexahedron)
00049 
00050 from pyNastran.bdf.bdf import (BDF, CAERO1, CAERO2, CAERO3, CAERO4, CAERO5,
00051                                CQUAD4, CQUAD8, CQUADR, CSHEAR,
00052                                CTRIA3, CTRIA6, CTRIAR, CTRIAX6,
00053                                CTETRA4, CTETRA10, CPENTA6, CPENTA15,
00054                                CHEXA8, CHEXA20,
00055                                CONM2,
00056                                LineElement, SpringElement)
00057 from pyNastran.op2.op2 import OP2
00058 
00059 
00060 class NastranIO(object):
00061     def __init__(self):
00062         pass
00063 
00064     def loadNastranGeometry(self, bdfFileName, dirname, isNodal, isCentroidal):
00065         self.isNodal = isNodal
00066         self.isCentroidal = isCentroidal
00067         #key = self.caseKeys[self.iCase]
00068         #case = self.resultCases[key]
00069         
00070         #skipReading = self.removeOldGeometry(bdfFileName)
00071         #if skipReading:
00072             #return
00073         if bdfFileName is None:
00074             self.grid       = vtk.vtkUnstructuredGrid()
00075             self.gridResult = vtk.vtkFloatArray()
00076             #self.emptyResult = vtk.vtkFloatArray()
00077             #self.vectorResult = vtk.vtkFloatArray()
00078             self.grid2      = vtk.vtkUnstructuredGrid()
00079             self.scalarBar.VisibilityOff()
00080             return
00081         else:
00082             self.TurnTextOff()
00083             self.grid.Reset()
00084             self.grid2.Reset()
00085             self.gridResult = vtk.vtkFloatArray()
00086             self.gridResult.Reset()
00087             self.gridResult.Modified()
00088             self.eidMap = {}
00089             self.nidMap = {}
00090 
00091             self.resultCases = {}
00092             self.nCases = 0
00093             try:
00094                 if hasattr(self,caseKeys):
00095                     del self.caseKeys
00096                 del self.iCase
00097                 del self.iSubcaseNameMap
00098             except NameError:
00099                 print("cant delete geo")
00100                 #pass
00101             ###
00102             #print dir(self)
00103         self.scalarBar.VisibilityOff()
00104         self.scalarBar.Modified()
00105 
00106         model = BDF()
00107         self.modelType = model.modelType
00108         model.readBDF(bdfFileName, includeDir=dirname)
00109 
00110         nNodes    = model.nNodes()
00111         nElements = model.nElements()
00112         nCAeros   = model.nCAeros()
00113         self.nNodes = nNodes
00114         self.nElements = nElements
00115 
00116         #print "nNodes = ",self.nNodes
00117         print("nElements = %i" %(self.nElements))
00118 
00119         #self.aQuadGrid.Allocate(nElements+nNodes, 1000)
00120 
00121         if 'CONM2' in model.cardCount:
00122             nCONM2 = model.cardCount['CONM2']
00123         else:
00124             nCONM2 = 0
00125         self.grid.Allocate(self.nElements, 1000)
00126         #self.gridResult.SetNumberOfComponents(self.nElements)
00127         #self.gridResult.SetNumberOfComponents(0)
00128         self.gridResult.SetNumberOfComponents(self.nElements)
00129         #self.gridResult.Allocate(self.nNodes,1000)
00130 
00131         self.grid2.Allocate(nCAeros+nCONM2, 1000)
00132 
00133         points = vtk.vtkPoints()
00134         points.SetNumberOfPoints(self.nNodes)
00135         self.gridResult.Allocate(self.nNodes, 1000)
00136         #vectorReselt.SetNumberOfComponents(3)
00137         self.nidMap = {}
00138         #elem.SetNumberOfPoints(nNodes)
00139         if 0:
00140             i = 0
00141             fraction = 1./nNodes # so you can color the nodes by ID
00142             for (nid, node) in sorted(model.nodes.iteritems()):
00143                 #print "i = ",i
00144                 point = node.Position()
00145                 #print "point = ",point
00146                 points.InsertPoint(i, *point)
00147                 self.gridResult.InsertNextValue(i*fraction)
00148                 #print str(element)
00149 
00150                 #elem = vtk.vtkVertex()
00151                 #elem.GetPointIds().SetId(0, i)
00152                 #self.aQuadGrid.InsertNextCell(elem.GetCellType(),
00153                 #                              elem.GetPointIds())
00154                 #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0)
00155 
00156                 self.nidMap[nid] = i
00157                 i += 1
00158         if 1:
00159             i = 0
00160             for (nid, node) in sorted(model.nodes.iteritems()):
00161                 point = node.Position()
00162                 points.InsertPoint(i, *point)
00163                 self.nidMap[nid] = i
00164                 i += 1
00165             #print "nidMap = ",self.nidMap
00166 
00167         j = 0
00168         points2 = vtk.vtkPoints()
00169         points2.SetNumberOfPoints(nCAeros*4+nCONM2)
00170         for (eid, element) in sorted(model.caeros.iteritems()):
00171             if (isinstance(element, CAERO1) or isinstance(element, CAERO3) or
00172                 isinstance(element, CAERO4) or isinstance(element, CAERO5)):
00173                 cpoints = element.Points()
00174                 elem = vtkQuad()
00175                 elem.GetPointIds().SetId(0, j)
00176                 elem.GetPointIds().SetId(1, j+1)
00177                 elem.GetPointIds().SetId(2, j+2)
00178                 elem.GetPointIds().SetId(3, j+3)
00179                 points2.InsertPoint(j,   *cpoints[0])
00180                 points2.InsertPoint(j+1, *cpoints[1])
00181                 points2.InsertPoint(j+2, *cpoints[2])
00182                 points2.InsertPoint(j+3, *cpoints[3])
00183                 self.grid2.InsertNextCell(elem.GetCellType(),
00184                                           elem.GetPointIds())
00185                 j += 4
00186             #elif isinstance(element,CAERO2): # cylinder
00187                 #pass
00188             else:
00189                 print("skipping %s" %(element.type))
00190                 
00191         self.mapElements(points, points2, self.nidMap, model, j)
00192 
00193     def mapElements(self, points, points2, nidMap, model, j):
00194         self.eidMap = {}
00195         i = 0
00196         for (eid, element) in sorted(model.elements.iteritems()):
00197             self.eidMap[eid] = i
00198             #print element.type
00199             if isinstance(element, CTRIA3) or isinstance(element, CTRIAR):
00200                 #print "ctria3"
00201                 elem = vtkTriangle()
00202                 nodeIDs = element.nodeIDs()
00203                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00204                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00205                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00206                 self.grid.InsertNextCell(elem.GetCellType(), 
00207                                          elem.GetPointIds())
00208             elif isinstance(element, CTRIA6):
00209                 nodeIDs = element.nodeIDs()
00210                 if None not in nodeIDs:
00211                     elem = vtkQuadraticTriangle()
00212                     elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00213                     elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00214                     elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00215                 else:
00216                     elem = vtkTriangle()
00217                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00218                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00219                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00220                 self.grid.InsertNextCell(elem.GetCellType(),
00221                                          elem.GetPointIds())
00222             elif isinstance(element, CTRIAX6):
00223                 # midside nodes are required, nodes out of order
00224                 nodeIDs = element.nodeIDs()
00225                 if None not in nodeIDs:
00226                     elem = vtkQuadraticTriangle()
00227                     elem.GetPointIds().SetId(3, nidMap[nodeIDs[1]])
00228                     elem.GetPointIds().SetId(4, nidMap[nodeIDs[3]])
00229                     elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00230                 else:
00231                     elem = vtkTriangle()
00232                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00233                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[2]])
00234                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[4]])
00235                 #a = [0,2,4]
00236                 #msg = "CTRIAX6 %i %i %i" %(nidMap[nodeIDs[a[0]]],
00237                 #                           nidMap[nodeIDs[a[1]]],
00238                 #                           nidMap[nodeIDs[a[2]]] )
00239                 #raise RuntimeError(msg)
00240                 #sys.stdout.flush()
00241                 
00242                 #elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00243                 #elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00244                 #elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00245                 self.grid.InsertNextCell(elem.GetCellType(),
00246                                          elem.GetPointIds())
00247 
00248             elif (isinstance(element, CQUAD4) or isinstance(element, CSHEAR) or
00249                   isinstance(element, CQUADR)):
00250                 nodeIDs = element.nodeIDs()
00251                 elem = vtkQuad()
00252                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00253                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00254                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00255                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00256                 self.grid.InsertNextCell(elem.GetCellType(),
00257                                          elem.GetPointIds())
00258             elif isinstance(element, CQUAD8):
00259                 nodeIDs = element.nodeIDs()
00260                 if None not in nodeIDs:
00261                     elem = vtkQuadraticQuad()
00262                     elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00263                     elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00264                     elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]])
00265                     elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]])
00266                 else:
00267                     elem = vtkQuad()
00268                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00269                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00270                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00271                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00272                 self.grid.InsertNextCell(elem.GetCellType(),
00273                                          elem.GetPointIds())
00274             elif isinstance(element, CTETRA4):
00275                 elem = vtkTetra()
00276                 nodeIDs = element.nodeIDs()
00277                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00278                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00279                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00280                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00281                 self.grid.InsertNextCell(elem.GetCellType(),
00282                                          elem.GetPointIds())
00283             elif isinstance(element, CTETRA10):
00284                 nodeIDs = element.nodeIDs()
00285                 if None not in nodeIDs:
00286                     elem = vtkQuadraticTetra()
00287                     elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00288                     elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00289                     elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]])
00290                     elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]])
00291                     elem.GetPointIds().SetId(8, nidMap[nodeIDs[8]])
00292                     elem.GetPointIds().SetId(9, nidMap[nodeIDs[9]])
00293                 else:
00294                     elem = vtkTetra()
00295                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00296                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00297                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00298                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00299                 self.grid.InsertNextCell(elem.GetCellType(),
00300                                          elem.GetPointIds())
00301             elif isinstance(element, CPENTA6):
00302                 elem = vtkWedge()
00303                 nodeIDs = element.nodeIDs()
00304                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00305                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00306                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00307                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00308                 elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00309                 elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00310                 self.grid.InsertNextCell(elem.GetCellType(),
00311                                          elem.GetPointIds())
00312 
00313             elif isinstance(element, CPENTA15):
00314                 nodeIDs = element.nodeIDs()
00315                 if None not in nodeIDs:
00316                     elem = vtkQuadraticWedge()
00317                     elem.GetPointIds().SetId(6,  nidMap[nodeIDs[6]])
00318                     elem.GetPointIds().SetId(7,  nidMap[nodeIDs[7]])
00319                     elem.GetPointIds().SetId(8,  nidMap[nodeIDs[8]])
00320                     elem.GetPointIds().SetId(9,  nidMap[nodeIDs[9]])
00321                     elem.GetPointIds().SetId(10, nidMap[nodeIDs[10]])
00322                     elem.GetPointIds().SetId(11, nidMap[nodeIDs[11]])
00323                     elem.GetPointIds().SetId(12, nidMap[nodeIDs[12]])
00324                     elem.GetPointIds().SetId(13, nidMap[nodeIDs[13]])
00325                     elem.GetPointIds().SetId(14, nidMap[nodeIDs[14]])
00326                 else:
00327                     elem = vtkWedge()
00328                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00329                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00330                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00331                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00332                 elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00333                 elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00334                 self.grid.InsertNextCell(elem.GetCellType(),
00335                                          elem.GetPointIds())
00336             elif isinstance(element, CHEXA8):
00337                 nodeIDs = element.nodeIDs()
00338                 elem = vtkHexahedron()
00339                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00340                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00341                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00342                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00343                 elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00344                 elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00345                 elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]])
00346                 elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]])
00347                 self.grid.InsertNextCell(elem.GetCellType(),
00348                                          elem.GetPointIds())
00349             elif isinstance(element, CHEXA20):
00350                 nodeIDs = element.nodeIDs()
00351                 #print "nodeIDs = ",nodeIDs
00352                 if None not in nodeIDs:
00353                     elem = vtkQuadraticHexahedron()
00354                     elem.GetPointIds().SetId(8,  nidMap[nodeIDs[8]])
00355                     elem.GetPointIds().SetId(9,  nidMap[nodeIDs[9]])
00356                     elem.GetPointIds().SetId(10, nidMap[nodeIDs[10]])
00357                     elem.GetPointIds().SetId(11, nidMap[nodeIDs[11]])
00358                     elem.GetPointIds().SetId(12, nidMap[nodeIDs[12]])
00359                     elem.GetPointIds().SetId(13, nidMap[nodeIDs[13]])
00360                     elem.GetPointIds().SetId(14, nidMap[nodeIDs[14]])
00361                     elem.GetPointIds().SetId(15, nidMap[nodeIDs[15]])
00362                     elem.GetPointIds().SetId(16, nidMap[nodeIDs[16]])
00363                     elem.GetPointIds().SetId(17, nidMap[nodeIDs[17]])
00364                     elem.GetPointIds().SetId(18, nidMap[nodeIDs[18]])
00365                     elem.GetPointIds().SetId(19, nidMap[nodeIDs[19]])
00366                 else:
00367                     elem = vtkHexahedron()
00368 
00369                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00370                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00371                 elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]])
00372                 elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]])
00373                 elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]])
00374                 elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]])
00375                 elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]])
00376                 elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]])
00377                 self.grid.InsertNextCell(elem.GetCellType(),
00378                                          elem.GetPointIds())
00379             elif (isinstance(element, LineElement) or
00380                   isinstance(element, SpringElement)):
00381                 elem = vtk.vtkLine()
00382                 nodeIDs = element.nodeIDs()
00383                 elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]])
00384                 elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]])
00385                 self.grid.InsertNextCell(elem.GetCellType(),
00386                                          elem.GetPointIds())
00387             ###
00388             elif isinstance(element, CONM2): # not perfectly located
00389                 del self.eidMap[eid]
00390                 i -= 1
00391 
00392                 nid  = element.Nid()
00393                 c    = element.Centroid()
00394                 elem = vtk.vtkVertex()
00395                 #elem = vtk.vtkSphere()
00396                 #elem.SetRadius(1.0)
00397                 #print str(element)
00398 
00399                 points2.InsertPoint(j, *c)
00400                 elem.GetPointIds().SetId(0, j)
00401                 #elem.SetCenter(points.GetPoint(nidMap[nid]))
00402                 self.grid2.InsertNextCell(elem.GetCellType(),
00403                                           elem.GetPointIds())
00404                 j += 1
00405             else:
00406                 del self.eidMap[eid]
00407                 i -= 1
00408 
00409                 print("skipping %s" %(element.type))
00410             i += 1
00411         ###
00412         self.grid.SetPoints(points)
00413         self.grid2.SetPoints(points2)
00414         #self.grid.GetPointData().SetScalars(self.gridResult)
00415         #print dir(self.grid) #.SetNumberOfComponents(0)
00416         #self.grid.GetCellData().SetNumberOfTuples(1);
00417         #self.grid.GetCellData().SetScalars(self.gridResult)
00418         self.grid.Modified()
00419         self.grid2.Modified()
00420         self.grid.Update()
00421         self.grid2.Update()
00422         print("updated grid")
00423 
00424 
00425     def loadNastranResults(self, op2FileName, dirname, isNodal, isCentroidal):
00426         #self.gridResult.SetNumberOfComponents(self.nElements)
00427         self.TurnTextOn()
00428         self.scalarBar.VisibilityOn()
00429         self.scalarBar.Modified()
00430 
00431         op2 = OP2(op2FileName, debug=True)
00432         op2.readOP2()
00433         #print op2.printResults()
00434         
00435         #case = op2.displacements[1]
00436         #print "case = ",case
00437         #for nodeID,translation in sorted(case.translations.iteritems()):
00438             #print "nodeID=%s t=%s" %(nodeID,translation)
00439         #self.iSubcaseNameMap[self.iSubcase] = [Subtitle,Label]
00440 
00441         cases = {}
00442         subcaseIDs = op2.iSubcaseNameMap.keys()
00443         self.iSubcaseNameMap = op2.iSubcaseNameMap
00444         
00445         nElements = len(self.eidMap)
00446         #print "nElements = ",nElements
00447         nidsSet = False # set to False to disable nodeIDs
00448         eidsSet = True
00449         for subcaseID in subcaseIDs:
00450             if nidsSet:
00451                 nids = zeros(self.nNodes, 'd')
00452                 for (nid, nid2) in self.nidMap.iteritems():
00453                     nids[nid2] = nid
00454                 cases[(subcaseID, 'Node_ID', 1, 'node', '%.0f')] = nids
00455                 nidsSet = True
00456 
00457             if eidsSet:
00458                 eids = zeros(nElements, 'd')
00459                 for (eid, eid2) in self.eidMap.iteritems():
00460                     eids[eid2] = eid
00461                
00462                 eKey = (subcaseID, 'isElementOn', 1, 'centroid', '%.0g')
00463                 cases[(subcaseID, 'Element_ID', 1, 'centroid', '%.0f')] = eids
00464                 cases[eKey] = zeros(nElements) # is the element supported
00465                 eidsSet = True
00466             
00467             if False:
00468                 if subcaseID in op2.displacements: # not correct?
00469                     case = op2.displacements[subcaseID]
00470                     key = (subcaseID, 'DisplacementX', 3, 'node', '%g')
00471                     #cases[key] = case.translations
00472 
00473                 if subcaseID in op2.temperatures:
00474                     case = op2.temperatures[subcaseID]
00475                     #print case
00476                     temps = zeros(self.nNodes)
00477                     key = (subcaseID, 'Temperature', 1, 'node', '%g')
00478                     for (nid, T) in case.temperatures.iteritems():
00479                         #print T
00480                         nid2 = self.nidMap[nid]
00481                         temps[nid2] = T
00482                     ###
00483                     #cases[key] = temps
00484 
00485             if self.isStress(op2, subcaseID):
00486                 cases = self.fillStressCase(cases, op2, subcaseID,
00487                                             eKey, nElements)
00488             ###
00489         ###
00490         self.resultCases = cases
00491         self.caseKeys = sorted(cases.keys())
00492         #print "caseKeys = ",self.caseKeys
00493         #print "type(caseKeys) = ",type(self.caseKeys)
00494         self.iCase = -1
00495         self.nCases = len(self.resultCases)-1 # number of keys in dictionary
00496         self.cycleResults() # start at nCase=0
00497 
00498     def fillStressCase(self, cases, op2, subcaseID, eKey, nElements):
00499         oxx = zeros(nElements)
00500         oyy = zeros(nElements)
00501         ozz = zeros(nElements)
00502 
00503         o1  = zeros(nElements)
00504         o2  = zeros(nElements)
00505         o3  = zeros(nElements)
00506         ovm = zeros(nElements)
00507 
00508         vmWord = 'N/A'
00509         if subcaseID in op2.rodStress:
00510             case = op2.rodStress[subcaseID]
00511             for eid in case.axial:
00512                 eid2 = self.eidMap[eid]
00513                 cases[eKey][eid2] = 1.
00514                 #print "bar eid=%s" %(eid)
00515 
00516                 axial   = case.axial[eid]
00517                 torsion = case.torsion[eid]
00518 
00519                 oxx[eid2] = axial
00520                 oyy[eid2] = torsion
00521 
00522                 o1[eid2]  = max(axial, torsion)  # not really
00523                 #oyy[eid2] = torsion
00524                 #o2[eid2] = 0.  #(o1i+o3i)/2.
00525                 o3[eid2] = min(axial, torsion)
00526 
00527         if subcaseID in op2.barStress:
00528             #self.s1    = {}
00529             #self.s2    = {}
00530             #self.s3    = {}
00531             #self.s4    = {}
00532             case = op2.barStress[subcaseID]
00533             for eid in case.axial:
00534                 eid2 = self.eidMap[eid]
00535                 cases[eKey][eid2] = 1.
00536 
00537                 #print "bar eid=%s" %(eid)
00538                 oxxi = case.axial[eid]
00539                 o1i  = max(case.smax[eid])
00540                 o3i  = min(case.smin[eid])
00541                 
00542                 oxx[eid2] = oxxi
00543                 #oyy[eid2] = oyyi
00544                 #ozz[eid2] = ozzi
00545 
00546                 o1[eid2] = o1i
00547                 #o2[eid2] = 0.  #(o1i+o3i)/2.
00548                 o3[eid2] = o3i
00549                 #ovm[eid2] = ovmi
00550 
00551         if subcaseID in op2.plateStress:
00552             #self.txy    = {}
00553             case = op2.plateStress[subcaseID]
00554             if case.isVonMises():
00555                 vmWord = 'vonMises'
00556             else:
00557                 vmWord = 'maxShear'
00558             for eid in case.ovmShear:
00559                 eid2 = self.eidMap[eid]
00560                 cases[eKey][eid2] = 1.
00561 
00562                 #print "plate eid=%s" %(eid)
00563                 oxxi = case.oxx[eid]['C']
00564                 #self.oyy[eid][nid][iLayer]
00565 
00566                 oxxi = max(case.oxx[eid]['C'])
00567                 oyyi = max(case.oyy[eid]['C'])
00568                 ozzi = min(case.oxx[eid]['C'], min(case.oyy[eid]['C']))
00569 
00570                 o1i = max(case.majorP[eid]['C'])
00571                 o2i = max(case.minorP[eid]['C'])
00572                 o3i = min(case.majorP[eid]['C'], min(case.minorP[eid]['C']))
00573                 ovmi = max(case.ovmShear[eid]['C'])
00574 
00575 
00576                 oxx[eid2] = oxxi
00577                 oyy[eid2] = oyyi
00578                 #ozz[eid2] = ozzi
00579 
00580                 o1[eid2] = o1i
00581                 #o2[eid2] = 0.  #(o1i+o3i)/2.
00582                 o3[eid2] = o3i
00583                 ovm[eid2] = ovmi
00584 
00585         if subcaseID in op2.solidStress:
00586             case = op2.solidStress[subcaseID]
00587             if case.isVonMises():
00588                 vmWord = 'vonMises'
00589             else:
00590                 vmWord = 'maxShear'
00591             for eid in case.ovmShear:
00592                 eid2 = self.eidMap[eid]
00593                 cases[eKey][eid2] = 1.
00594 
00595                 #print "solid eid=%s" %(eid)
00596                 oxxi = case.oxx[eid]['C']
00597                 oyyi = case.oyy[eid]['C']
00598                 ozzi = case.ozz[eid]['C']
00599                 o1i = case.o1[eid]['C']
00600                 o2i = case.o2[eid]['C']
00601                 o3i = case.o3[eid]['C']
00602                 ovmi = case.ovmShear[eid]['C']
00603                 #if subcaseID==1:
00604                     #print "ovm[%s] = %s" %(eid,ovmi)
00605                 oxx[eid2] = oxxi
00606                 oyy[eid2] = oyyi
00607                 ozz[eid2] = ozzi
00608 
00609                 o1[eid2] = o1i
00610                 o2[eid2] = o2i
00611                 o3[eid2] = o3i
00612                 ovm[eid2] = ovmi
00613             ###
00614 
00615         # subcaseID,resultType,vectorSize,location,dataFormat
00616         cases[(subcaseID, 'StressXX', 1, 'centroid', '%.3f')] = oxx
00617         cases[(subcaseID, 'StressYY', 1, 'centroid', '%.3f')] = oyy
00618         cases[(subcaseID, 'StressZZ', 1, 'centroid', '%.3f')] = ozz
00619 
00620         cases[(subcaseID, 'Stress1', 1, 'centroid', '%.3f')] = o1
00621         cases[(subcaseID, 'Stress2', 1, 'centroid', '%.3f')] = o2
00622         cases[(subcaseID, 'Stress3', 1, 'centroid', '%.3f')] = o3
00623         cases[(subcaseID, vmWord,    1, 'centroid', '%.3f')] = ovm
00624         return cases
00625     
00626 
 All Classes Namespaces Files Functions Variables