pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
bars.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,R0902,R0904,R0914
00026 """
00027 All beam properties are defined in this file.  This includes:
00028     PBEAM
00029     PBEAML
00030     PBAR
00031     PBARL
00032     PROD
00033     PTUBE
00034 
00035 All beams are LineProperty objects.
00036 Multi-segment beams are IntegratedLineProperty objects.
00037 """
00038 
00039 from __future__ import division, print_function
00040 #import sys
00041 from itertools import izip, count
00042 from numpy import zeros, pi
00043 
00044 from pyNastran.bdf.fieldWriter import (set_blank_if_default,
00045                                        set_default_if_blank)
00046 from pyNastran.general.generalMath import integrateLine, integratePositiveLine
00047 from pyNastran.bdf.cards.baseCard import Property
00048 
00049 
00050 def IyyBeam(b, h):
00051     return 1/12.*b*h**3
00052 
00053 def IBeam(b, h):
00054     f = 1/12.*b*h
00055     
00056     Iyy = f*h*h # 1/12.*b*h**3
00057     Izz = f*b*b # 1/12.*h*b**3
00058     Iyz = 0.
00059     return (Iyy, Izz, Iyz)
00060 
00061 def IBeamOffset(b, h, y, z):
00062     A = b*h
00063     f = 1./12.*A
00064     
00065     Iyy = f*h*h # 1/12.*b*h**3
00066     Izz = f*b*b # 1/12.*h*b**3
00067     Iyz = 0.
00068     
00069     Iyy += A*y*y
00070     Izz += A*z*z
00071     Iyz += A*y*z
00072     return (Iyy, Izz, Iyz)
00073 
00074 
00075 def getInertiaRectangular(sections):
00076     """
00077     calculates the moment of inertia for a section about the CG
00078     @param sections
00079       [[b,h,y,z]_1,...] y,z is the centroid (x in the direction of the beam,
00080       y right, z up)
00081     @retval interiaParameters
00082         list of [Area,Iyy,Izz,Iyz]
00083     @see http://www.webs1.uidaho.edu/mindworks/Machine_Design/Posters/PDF/Moment%20of%20Inertia.pdf
00084     """
00085     As = []
00086     Ax = 0.
00087     Ay = 0.
00088     for section in sections:
00089         (b, h, x, y) = section
00090         A = b*h
00091         As.append(A)
00092         Ax += A*x
00093         Ay += A*y
00094 
00095     xCG = Ax/A
00096     yCG = Ay/A
00097     Axx = 0.
00098     Ayy = 0.
00099     Axy = 0.
00100     for (i, section) in enumerate(sections):
00101         (b, h, x, y) = section
00102         #A = b*h
00103         #As.append(A)
00104         Axx += As[i]*(x-xCG)**2
00105         Ayy += As[i]*(y-yCG)**2
00106         Axy += As[i]*(x-xCG)*(y-yCG)
00107     Ixx = Axx/A
00108     Iyy = Ayy/A
00109     Ixy = Axy/A
00110     return (A, Ixx, Iyy, Ixy)
00111 
00112        
00113 
00114 
00115 class LineProperty(Property):
00116     type = 'LineProperty'
00117     def __init__(self, card, data):
00118         self.Type = None
00119         self.dim = None
00120         self.A = None
00121         self.i1 = None
00122         self.i2 = None
00123         self.i12 = None
00124         self.j = None
00125         self.nsm = None
00126         Property.__init__(self, card, data)
00127     def D_bending(self):
00128         pass
00129     def D_axial(self):
00130         pass
00131     def D_thermal(self):
00132         pass
00133     def D_shear(self):
00134         pass
00135     
00136     def Rho(self):
00137         return self.mid.rho
00138 
00139     def Area(self):
00140         return self.A
00141 
00142     def Nsm(self):
00143         return self.nsm
00144 
00145     def J(self):
00146         return self.j
00147 
00148     def I11(self):
00149         return self.i1
00150 
00151     def I22(self):
00152         return self.i2
00153 
00154     def I12(self):
00155         return self.i12
00156 
00157     def E(self):
00158         return self.mid.E
00159 
00160     def G(self):
00161         return self.mid.G
00162 
00163     def Nu(self):
00164         return self.mid.nu
00165 
00166     def CA_Section(self,iFace,iStart,dims):
00167         """
00168         ---msg1---
00169         H1=0.1
00170         W1=0.05
00171 
00172         ---msg2---
00173         Face_1 = geompy.MakeFaceHW(H1, W1, 1)
00174         geompy.addToStudy( Face_1, 'Face_1' )
00175         
00176         ---msg---
00177         H1=0.1
00178         W1=0.05
00179         Face_1 = geompy.MakeFaceHW(H1, W1, 1)
00180         geompy.addToStudy( Face_1, 'Face_1' )
00181         """
00182         msg1 = ''
00183         msg2 = 'Face_%s = geompy.MakeFaceHW(' % (iFace+1)
00184         for (i, dim) in enumerate(dims):
00185             msg1 += 'D%s = %s\n' % (iStart+i, dim)
00186             msg2 += 'D%s,' % (iStart+i)
00187         msg2 += '1)\n'
00188         msg2 += "geompy.addToStudy(Face_%i, 'Face_%i')\n" % (iFace, iFace)
00189         return (msg1+msg2)
00190             
00191     def IAreaL(self, dim):
00192         if self.Type == 'ROD':
00193             R = dim[0]
00194             A = pi*R**2
00195             Iyy = A*R**2/4.
00196             Izz = Iyy
00197             Iyz = 0.
00198         elif self.Type == 'TUBE':
00199             R1 = dim[0]
00200             R2 = dim[1]
00201             A1   = pi*R1**2
00202             Iyy1 = A1*R1**2/4.
00203             A2   = pi*R2**2
00204             Iyy2 = A2*R2**2/4.
00205             A   = A1-A2
00206             Iyy = Iyy1-Iyy2
00207             Izz = Iyy
00208             Iyz = 0.
00209 
00210         elif self.Type == 'I':
00211             sections = []
00212             h1 = dim[5]                         #        d2
00213             w1 = dim[2]                         # |  ------------
00214             y1 = dim[0]/2.-h1                   # |  |    A     | d5
00215             sections.append([w1, h1, 0., y1])   # |  ------------
00216                                                 # |     >| |<--d3
00217             h3 = dim[4]                         # |      |B|
00218             w3 = dim[1]                         # | d1   | |
00219             y3 = -dim[0]/2.+h3                  # |      | |
00220             sections.append([w3, h3, 0., y1])   # |   ----------
00221                                                 # |   |   C    |  d5
00222             h2 = dim[0]-h1-h3                   # |   ----------
00223             w2 = dim[3]                         #         d1
00224             sections.append([w2, h2, 0., 0.])
00225 
00226             (A, Iyy, Izz, Iyz) = getInertiaRectangular(sections)
00227             assert Iyz == 0.
00228 
00229         elif self.Type == 'BAR':    #  *-------*
00230             h1 = dim[1]           #  |       |
00231             w1 = dim[0]           #  |       |h1
00232             A = h1*w1             #  |       |
00233             Iyy = 1/12.*w1*h1**3  #  *-------*          I_{xx}=\frac{bh^3}{12}
00234             Izz = 1/12.*h1*w1**3  #      w1             I_{yy}=\frac{hb^3}{12}
00235             Iyz = 0. ## @todo is the Ixy of a bar 0 ???
00236             
00237         else:
00238             msg = 'Type=%s is not supported for %s class...' % (self.Type,
00239                                                                 self.type)
00240             raise NotImplementedError(msg)
00241         return (A, Iyy, Izz, Iyz)
00242     
00243     def I1(self):
00244         return self.I1_I2()[0]
00245 
00246     def I2(self):
00247         return self.I1_I2()[1]
00248 
00249     def I1_I2(self):
00250         """
00251         BAR
00252             2
00253             ^ 
00254             |
00255         *---|--*
00256         |   |  |
00257         |   |  |
00258         |h  *-----------> 1
00259         |      |
00260         |   b  |
00261         *------*
00262         I1 = 1/12*b*h^3
00263         I2 = 1/12*h*b^3
00264         """
00265         dim = self.dim
00266         if self.Type == 'BAR':
00267             I1 = 1/12.*dim[0]*dim[1]**3
00268             I2 = 1/12.*dim[1]*dim[0]**3
00269         return(I1, I2)
00270 
00271     def areaL(self, dim):
00272         """
00273         Area method for the PBARL and PBEAML classes (pronounced Area-L)
00274         @param self the object pointer
00275         @param dim a list of the dimensions associated with self.Type
00276         @retval Area of the given cross section
00277         """
00278         try:
00279             if   self.Type == 'ROD':
00280                 A = pi*dim[0]**2
00281             elif self.Type == 'TUBE':
00282                 A = pi*(dim[0]**2-dim[1]**2)
00283             elif self.Type == 'I':
00284                 h1 = dim[5]
00285                 w1 = dim[2]
00286     
00287                 h3 = dim[4]
00288                 w3 = dim[1]
00289     
00290                 h2 = dim[0]-h1-h3
00291                 w2 = dim[3]
00292                 A = h1*w1+h2*w2+h3*w3
00293             elif self.Type == 'CHAN':
00294                 h1 = dim[3]
00295                 w1 = dim[0]
00296     
00297                 h3 = h1
00298                 w3 = w1
00299                 h2 = dim[1]-h1-h3
00300                 w2 = dim[2]
00301                 A = h1*w1+h2*w2+h3*w3
00302             elif self.Type == 'T':
00303                 h1 = dim[2]
00304                 w1 = dim[0]
00305     
00306                 h2 = dim[1]-h1
00307                 w2 = dim[3]
00308                 A = h1*w1+h2*w2
00309             elif self.Type == 'BOX':
00310                 h1 = dim[2]
00311                 w1 = dim[0]
00312     
00313                 h2 = dim[1]-2*h1
00314                 w2 = dim[3]
00315                 A = 2*(h1*w1+h2*w2)
00316             elif self.Type == 'BAR':
00317                 h1 = dim[1]
00318                 w1 = dim[0]
00319                 A = h1*w1
00320             elif self.Type == 'CROSS':
00321                 h1 = dim[2]
00322                 w1 = dim[1]
00323     
00324                 h2 = dim[3]
00325                 w2 = dim[0]
00326                 A = h1*w1+h2*w2
00327             elif self.Type == 'H':
00328                 h1 = dim[2]
00329                 w1 = dim[1]
00330     
00331                 h2 = dim[3]
00332                 w2 = dim[0]
00333                 A = h1*w1+h2*w2
00334             elif self.Type == 'T1':
00335                 h1 = dim[0]
00336                 w1 = dim[2]
00337     
00338                 h2 = dim[3]
00339                 w2 = dim[1]
00340                 A = h1*w1+h2*w2
00341             elif self.Type == 'I1':
00342                 h2 = dim[2]
00343                 w2 = dim[1]
00344     
00345                 h1 = dim[3]-h2
00346                 w1 = dim[0]+w2
00347                 A = h1*w1+h2*w2
00348             elif self.Type == 'CHAN1':
00349                 h2 = dim[2]
00350                 w2 = dim[1]
00351     
00352                 h1 = dim[3]-h2
00353                 w1 = dim[0]+w2
00354                 A = h1*w1+h2*w2
00355             elif self.Type == 'Z':
00356                 h2 = dim[2]
00357                 w2 = dim[1]
00358     
00359                 h1 = dim[3]-h2
00360                 w1 = dim[0]
00361                 A = h1*w1+h2*w2
00362             elif self.Type == 'CHAN2':
00363                 h2 = dim[1]
00364                 w2 = dim[3]
00365     
00366                 h1 = dim[2]-h2
00367                 w1 = dim[0]*2
00368                 A = h1*w1+h2*w2
00369     
00370             elif self.Type == 'T2':
00371                 h1 = dim[3]
00372                 w1 = dim[1]
00373     
00374                 h2 = h1-dim[2]
00375                 w2 = dim[0]
00376                 A = h1*w1+h2*w2
00377             elif self.Type == 'BOX1':
00378                 h1 = dim[2]  # top
00379                 w1 = dim[0]
00380                 
00381                 h2 = dim[3] # btm
00382                 A1 = (h1+h2)*w1
00383                 
00384                 h3 = dim[1]-h1-h2  # left
00385                 w3 = dim[5]
00386                 
00387                 w4 = dim[4] # right
00388                 A2 = h3*(w3+w4)
00389                 A  = A1+A2
00390             elif self.Type == 'HEXA':
00391                 hBox = dim[2]
00392                 wBox = dim[1]
00393     
00394                 wTri = dim[0]
00395                 A = hBox*wBox - wTri*hBox
00396             elif self.Type == 'HAT':
00397                 w  = dim[1]      # constant width (note h is sometimes w)
00398                 h1 = w           # horizontal lower bar
00399                 w1 = dim[3]
00400                 
00401                 h2 = dim[0]-2*w  # vertical bar
00402                 w2 = w
00403                 
00404                 h3 = w           # half of top bar
00405                 w3 = dim[2]/2.
00406                 
00407                 A = 2*(h1*w1+h2*w2+h3*w3)  # symmetrical box
00408             elif self.Type == 'HAT1':
00409                 w = dim[3]
00410                 
00411                 h0 = dim[4]         # btm bar
00412                 w0 = dim[0]/2.
00413     
00414                 h2 = dim[1]-h0-2*w  # vertical bar
00415                 w2 = w
00416     
00417                 h3 = w              # top bar
00418                 w3 = dim[2]/2.
00419     
00420                 h1 = w              # upper, horizontal lower bar (see HAT)
00421                 w1 = w0-w3
00422                 
00423                 A = 2*(h0*w0+h1*w1+h2*w2+h3*w3)
00424                 
00425             elif self.Type == 'DBOX':
00426                 #
00427                 #  |--2------5----
00428                 #  |     |       |
00429                 #  1     3       6
00430                 #  |     |       |
00431                 #  |--4--|---7---|
00432                 #
00433                 
00434                 #0,1,2,6,11
00435                 #1,2,3,7,12
00436                 
00437                 hTotal = dim[11]
00438                 wTotal = dim[0]
00439     
00440                 h2 = dim[6]
00441                 w2 = dim[3]
00442     
00443                 h4 = dim[7]
00444                 w4 = w2
00445     
00446                 h1 = hTotal-h2-h4
00447                 w1 = dim[3]
00448                 
00449                 h5 = dim[8]
00450                 w5 = wTotal-w2
00451     
00452                 h7 = dim[9]
00453                 w7 = w5
00454     
00455                 h6 = hTotal-h5-h7
00456                 w6 = dim[5]
00457     
00458                 h3 = (h1+h6)/2.
00459                 w3 = dim[4]
00460                 
00461                 A = h1*w1 +h2*w2 +h3*w3 +h4*w4 +h5*w5 +h6*w6 +h7*w7
00462             else:
00463                 msg = 'Type=%s is not supported for %s class...' % (self.Type,
00464                                                                     self.type)
00465                 raise NotImplementedError(msg)
00466         except IndexError as e:
00467             msg = 'There was an error extracting fields'
00468             msg += ' from a %s dim=%s for a %s' % (self.Type, dim, self.type)
00469             msg += '-'*80+'\n'
00470             msg += 'Traceback:\n%s' % (e.message)
00471             raise IndexError(msg)
00472         return A
00473 
00474 class IntegratedLineProperty(LineProperty):
00475     type = 'IntegratedLineProperty'
00476     def __init__(self, card, data):
00477         self.xxb = None
00478         self.A = None
00479         self.j = None
00480         self.i1 = None
00481         self.i2 = None
00482         self.i12 = None
00483         LineProperty.__init__(self, card, data)
00484 
00485     def Area(self):
00486         A = integratePositiveLine(self.xxb, self.A)
00487         return A
00488 
00489     def J(self):
00490         J = integratePositiveLine(self.xxb, self.j)
00491         return J
00492 
00493     def I11(self):
00494         i1 = integratePositiveLine(self.xxb, self.i1)
00495         return i1
00496 
00497     def I22(self):
00498         i2 = integratePositiveLine(self.xxb, self.i2)
00499         return i2
00500 
00501     def I12(self):
00502         i12 = integrateLine(self.xxb, self.i12)
00503         return i12
00504 
00505     def Nsm(self):
00506         #print "xxb = ",self.xxb
00507         #print "nsm = ",self.nsm
00508         nsm = integratePositiveLine(self.xxb, self.nsm)
00509         return nsm
00510 
00511         
00512 class PROD(LineProperty):
00513     type = 'PROD'
00514     def __init__(self, card=None, data=None):
00515         LineProperty.__init__(self, card, data)
00516 
00517         if card:
00518             self.pid = card.field(1)
00519             self.mid = card.field(2)
00520             self.A   = card.field(3)
00521             self.j   = card.field(4, 0.0)
00522             self.c   = card.field(5, 0.0)
00523             self.nsm = card.field(6, 0.0)
00524         else:
00525             self.pid = data[0]
00526             self.mid = data[1]
00527             self.A   = data[2]
00528             self.j   = data[3]
00529             self.c   = data[4]
00530             self.nsm = data[5]
00531         ###
00532 
00533     #def Radius(self):
00534         #"""assumes circular cross section - probably will remove this"""
00535         #return (self.A/pi)**0.5
00536         
00537     def crossReference(self, model):
00538         self.mid = model.Material(self.mid)
00539 
00540     #def I11(self):
00541         #"""@todo whats the proper formula to use for a ROD"""
00542         #return self.j/2.
00543 
00544     #def I22(self):
00545         #"""@todo whats the proper formula to use for a ROD"""
00546         #return self.j/2.
00547 
00548     #def I12(self):
00549         #return 0.
00550 
00551     def writeCodeAster(self, iCut, iFace, iStart): # PROD
00552         msg = ''
00553         msg += "    POUTRE=_F(GROUP_MA='P%s', # PROD\n" % (self.pid)
00554         msg += "              SECTION='CERCLE',  # circular section\n"
00555         msg += "              CARA=('R')   # radius\n"
00556         msg += "              VALE=(%g),),\n"  % (self.Radius())
00557         
00558         #msg += "              SECTION='GENERALE',\n"
00559         #msg += "              CARA=('A','IY','IZ','JX')\n"
00560         #msg += "              VALE=(%g,  %g,  %g,  %g),\n"  %(self.Area(),self.I11(),self.I22(),self.J())
00561         #msg += "                    CARA='VECT_Y'),\n"
00562         #msg += "                    VALE=(1.0,0.0,0.0,),),\n"
00563         return (msg, iCut, iFace, iStart)
00564 
00565     def rawFields(self):
00566         fields = ['PROD', self.pid, self.Mid(), self.A, self.j, self.c,
00567                   self.nsm]
00568         return fields
00569         
00570     def reprFields(self):
00571         j   = set_blank_if_default(self.j, 0.0)
00572         c   = set_blank_if_default(self.c, 0.0)
00573         nsm = set_blank_if_default(self.nsm, 0.0)
00574         fields = ['PROD', self.pid, self.Mid(), self.A, j, c, nsm]
00575         return fields
00576 
00577 class PTUBE(LineProperty):
00578     type = 'PTUBE'
00579     def __init__(self, card=None, data=None):
00580         LineProperty.__init__(self, card, data)
00581         if card:
00582             self.pid = card.field(1)
00583             self.mid = card.field(2)
00584             self.OD1 = card.field(3)
00585             self.t   = card.field(4, self.OD1/2.)
00586             self.nsm = card.field(5, 0.0)
00587             self.OD2 = card.field(6, self.OD1)
00588         else:
00589             self.pid = data[0]
00590             self.mid = data[1]
00591             self.OD1 = data[2]
00592             self.t   = data[3]
00593             self.nsm = data[4]
00594             self.OD2 = self.OD1
00595             #self.OD2 = data[5]  ## @note quirk to this one...
00596 
00597     def crossReference(self, model):
00598         self.mid = model.Material(self.mid)
00599 
00600     def Area(self):
00601         A = (self.area1()+self.area2())/2.
00602         
00603         #A1 = pi*D1^2/4 - pi*((D1-2t)^2)/4
00604         #A2 = pi*D2^2/4 - pi*((D2-2t)^2)/4
00605         #A = A1+A2
00606         
00607         #A = pi*D1*t/2 + pi*D2*t/2 - pi*t
00608         #A = pi*t*(D1/2 + D2/2 - t)
00609         #A = pi*t*( (D1+D2)/2.-t )
00610         
00611         #A2 = pi*t*( (D1+D2)/2.-t )
00612         
00613         #if A != A2:
00614             #msg = 'AREA method has problem in PTUBE Aold=%s != Anew=%s' %(A,A2)
00615             #raise RuntimeError(msg)
00616         return A
00617         
00618     def area1(self):
00619         """@todo remove after verifying formula..."""
00620         Dout = self.OD1
00621         Din  = Dout-2*self.t
00622         A1 = pi/4.*(Dout*Dout-Din*Din)
00623         return A1
00624 
00625     def area2(self):
00626         """@todo remove after verifying formula..."""
00627         Dout = self.OD2
00628         Din  = Dout-2*self.t
00629         A2 = pi/4.*(Dout*Dout-Din*Din)
00630         return A2
00631 
00632     def massMatrix(self):
00633         """@todo not done"""
00634         m = zeros(6, 6)
00635         m[0, 0] = 1.
00636         return m
00637 
00638     def rawFields(self):
00639         fields = ['PTUBE', self.pid, self.Mid(), self.OD1, self.t, self.nsm,
00640                   self.OD2]
00641         return fields
00642     
00643     def reprFields(self):
00644         t   = set_blank_if_default(self.t, self.OD1/2.)
00645         nsm = set_blank_if_default(self.nsm, 0.0)
00646         OD2 = set_blank_if_default(self.OD2, self.OD1)
00647         fields = ['PTUBE', self.pid, self.Mid(), self.OD1, t, nsm, OD2]
00648         return fields
00649     
00650 class PBAR(LineProperty):
00651     type = 'PBAR'
00652     def __init__(self, card=None, data=None):
00653         """
00654         @todo
00655             support solution 600 default
00656             do a check for mid -> MAT1      for structural
00657             do a check for mid -> MAT4/MAT5 for thermal
00658         """
00659         LineProperty.__init__(self, card, data)
00660         if card:
00661             ## property ID -> use Pid()
00662             self.pid = card.field(1)
00663             ## material ID -> use Mid()
00664             self.mid = card.field(2)
00665             ## Area -> use Area()
00666             self.A   = card.field(3, 0.0)
00667             ## Izz -> use Izz()
00668             self.i1  = card.field(4, 0.0)
00669             ## Iyy -> use Iyy()
00670             self.i2  = card.field(5, 0.0)
00671             ## Polar Moment of Inertia J -> use J()
00672             # default=1/2(I1+I2) for SOL=600,otherwise 0.0
00673             self.j   = card.field(6, 0.0)
00674             ## nonstructral mass -> use Nsm()
00675             self.nsm = card.field(7, 0.0)
00676 
00677             self.C1  = card.field(9,  0.0)
00678             self.C2  = card.field(10, 0.0)
00679             self.D1  = card.field(11, 0.0)
00680             self.D2  = card.field(12, 0.0)
00681             self.E1  = card.field(13, 0.0)
00682             self.E2  = card.field(14, 0.0)
00683             self.F1  = card.field(15, 0.0)
00684             self.F2  = card.field(16, 0.0)
00685 
00686             self.K1  = card.field(17, 1e8) ## default=infinite
00687             self.K2  = card.field(18, 1e8) ## default=infinite
00688             self.i12 = card.field(19, 0.0)
00689             if self.A == 0.0:
00690                 assert self.K1 == None
00691                 assert self.K2 == None
00692             ###
00693         else:
00694             self.pid = data[0]
00695             self.mid = data[1]
00696             self.A   = data[2]
00697             self.i1  = data[3]
00698             self.i2  = data[4]
00699             self.j   = data[5]
00700 
00701             self.nsm = data[6]
00702             #self.fe  = data[7] ## @todo not documented....
00703             self.C1  = data[8]
00704             self.C2  = data[9]
00705             self.D1  = data[10]
00706             self.D2  = data[11]
00707             self.E1  = data[12]
00708             self.E2  = data[13]
00709             self.F1  = data[14]
00710             self.F2  = data[15]
00711             self.K1  = data[16]
00712             self.K2  = data[17]
00713             self.i12 = data[18]
00714         ###
00715 
00716     def MassPerLength(self):
00717         """
00718         \f[ \frac{m}{L} = \rho A+nsm \f]
00719         """
00720         A   = self.Area()
00721         rho = self.Rho()
00722         nsm = self.Nsm()
00723         return rho*A+nsm
00724 
00725     def crossReference(self, model):
00726         self.mid = model.Material(self.mid)
00727 
00728     def Area(self):
00729         return self.A
00730 
00731     #def Nsm(self):
00732     #    return self.nsm
00733 
00734     #def J(self):
00735     #    return self.j
00736 
00737     #def Izz(self):
00738     #    return self.i1
00739 
00740     #def Iyy(self):
00741     #    return self.i2
00742 
00743     #def Iyz(self):
00744     #    return self.i12
00745 
00746     def writeCodeAster(self): # PBAR
00747         a  = self.Area()
00748         iy = self.I11()
00749         iz = self.I22()
00750         j  = self.J()
00751         msg = ''
00752         msg += "    POUTRE=_F(GROUP_MA='P%s', # PBAR\n" % (self.pid)
00753         msg += "              SECTION='GENERALE',\n"
00754         msg += "              CARA=('A','IY','IZ','JX')\n"
00755         msg += "              VALE=(%g,  %g,  %g,  %g,)\n"  % (a, iy, iz, j)
00756         msg += "              ORIENTATION=(\n"
00757         msg += "                    CARA=('VECT_Y'),\n"
00758         msg += "                    VALE=(1.0,0.0,0.0,),),\n"
00759         return (msg)
00760 
00761     def rawFields(self):
00762         fields = ['PBAR', self.pid, self.Mid(), self.A, self.i1, self.i2,
00763                   self.j, self.nsm, None, self.C1, self.C2, self.D1, self.D2,
00764                   self.E1, self.E2, self.F1, self.F2, self.K1, self.K2,
00765                   self.i12]
00766         return fields
00767 
00768     def reprFields(self):
00769         #A  = set_blank_if_default(self.A,0.0)
00770         i1  = set_blank_if_default(self.i1, 0.0)
00771         i2  = set_blank_if_default(self.i2, 0.0)
00772         i12 = set_blank_if_default(self.i12, 0.0)
00773         j   = set_blank_if_default(self.j, 0.0)
00774         nsm = set_blank_if_default(self.nsm, 0.0)
00775         
00776         C1  = set_blank_if_default(self.C1, 0.0)
00777         C2  = set_blank_if_default(self.C2, 0.0)
00778 
00779         D1  = set_blank_if_default(self.D1, 0.0)
00780         D2  = set_blank_if_default(self.D2, 0.0)
00781 
00782         E1  = set_blank_if_default(self.E1, 0.0)
00783         E2  = set_blank_if_default(self.E2, 0.0)
00784 
00785         F1  = set_blank_if_default(self.F1, 0.0)
00786         F2  = set_blank_if_default(self.F2, 0.0)
00787         
00788         K1  = set_blank_if_default(self.K1, 1e8)
00789         K2  = set_blank_if_default(self.K2, 1e8)
00790 
00791         #print "line3 = ",line3
00792         
00793         fields = ['PBAR', self.pid, self.Mid(), self.A, i1, i2, j, nsm, None,
00794                   C1, C2, D1, D2, E1, E2, F1, F2,
00795                   K1, K2, i12]
00796 
00797         return fields
00798 
00799 class PBARL(LineProperty):
00800     """
00801     @warning doesnt support user-defined types
00802     """
00803     type = 'PBARL'
00804     validTypes = {
00805         "ROD"   : 1, 
00806         "TUBE"  : 2,
00807         "I"     : 6,
00808         "CHAN"  : 4,
00809         "T"     : 4,
00810         "BOX"   : 4,
00811         "BAR"   : 2,
00812         "CROSS" : 4,
00813         "H"     : 4,
00814         "T1"    : 4,
00815         "I1"    : 4,
00816         "CHAN1" : 4,
00817         "Z"     : 4,
00818         "CHAN2" : 4,
00819         "T2"    : 4,
00820         "BOX1"  : 6,
00821         "HEXA"  : 3,
00822         "HAT"   : 4,
00823         "HAT1"  : 5,
00824         "DBOX"  : 10, # was 12
00825         } # for GROUP="MSCBML0"
00826 
00827     def __init__(self, card=None, data=None):
00828         LineProperty.__init__(self, card, data)
00829         if card:
00830             self.pid   = card.field(1)
00831             self.mid   = card.field(2)
00832             self.group = card.field(3, 'MSCBMLO')
00833             self.Type  = card.field(4)
00834 
00835             #nDim = len(self.dim)-1
00836             nDim = self.validTypes[self.Type]
00837             self.dim = card.fields(9, 9+nDim+1)
00838             self.nsm = card.field(9+nDim+1, 0.0)
00839 
00840             #self.dim = fields(9)
00841             if nDim > 0:
00842                 self.nsm = set_default_if_blank(self.dim.pop(), 0.0)
00843             else:
00844                 self.nsm = 0.0
00845             ###
00846             assert isinstance(self.nsm, float)
00847         else:
00848             self.pid   = data[0]
00849             self.mid   = data[1]
00850             self.group = data[2].strip()
00851             self.Type  = data[3].strip()
00852             self.dim   = list(data[4:-1])
00853             self.nsm   = data[-1]
00854             #print "group = |%s|" %(self.group)
00855             #print "Type  = |%s|" %(self.Type)
00856             #print "dim = ",self.dim
00857             #print str(self)
00858             #print "*PBARL = ",data
00859             #raise NotImplementedError('not finished...')
00860         if self.Type not in self.validTypes:
00861             msg = ('Invalid PBARL Type, Type=%s '
00862                    'validTypes=%s' %(self.Type, self.validTypes.keys()))
00863             raise RuntimeError(msg)
00864 
00865         if len(self.dim) != self.validTypes[self.Type]:
00866             msg = 'dim=%s len(dim)=%s Type=%s len(dimType)=%s' % (
00867                    self.dim, len(self.dim), self.Type,
00868                    self.validTypes[self.Type])
00869             raise RuntimeError(msg)
00870 
00871         assert None not in self.dim
00872             
00873     def crossReference(self, model):
00874         self.mid = model.Material(self.mid)
00875 
00876     def Area(self):
00877         return self.areaL(self.dim)
00878 
00879     def Nsm(self):
00880         return self.nsm
00881     
00882     def MassPerLength(self):
00883         """
00884         mass = L*(Area*rho+nsm)
00885         mass/L = Area*rho+nsm
00886         """
00887         rho  = self.Rho()
00888         area = self.Area()
00889         nsm  = self.Nsm()
00890         return area*rho+nsm
00891 
00892     def I11(self):
00893         return None
00894     def I12(self):
00895         return None
00896     def J(self):
00897         return None
00898     def I22(self):
00899         return None
00900     
00901     def writeCodeAster(self, iCut=0, iFace=0, iStart=0):  # PBARL
00902         msg = '# BAR Type=%s pid=%s\n' % (self.type, self.pid)
00903         msg2 = ''
00904         (msg) += self.CA_Section(iFace, iStart, self.dim)
00905         iFace += 1
00906         iStart += len(self.dim)
00907 
00908         (msg) += self.CA_Section(iFace, iStart, self.dim)
00909         iFace += 1
00910         msg2 += 'Cut_%s = geompy.MakeCut(Face_%i, Face_%i)\n' % (iCut+1, iFace+1, iFace+2)
00911         msg2 += "geompy.addToStudy(Cut_%i,  'Cut_%i')\n"  % (iCut+1, iCut+1)
00912         iStart += len(self.dim)
00913         return (msg+msg2, iCut, iFace, iStart)
00914 
00915     def rawFields(self):
00916         fields = ['PBARL', self.pid, self.Mid(), self.group, self.Type, None,
00917                   None, None, None,]+self.dim+[self.nsm]
00918         return fields
00919 
00920     def reprFields(self):
00921         group = set_blank_if_default(self.group, 'MSCBMLO')
00922         fields = ['PBARL', self.pid, self.Mid(), group, self.Type, None, None,
00923                   None, None,]+self.dim+[self.nsm]
00924         return fields
00925 
00926 class PBEAM(IntegratedLineProperty):
00927     type = 'PBEAM'
00928     def __init__(self, card=None, data=None):
00929         """
00930         @todo fix 0th entry of self.so, self.xxb
00931         """
00932         IntegratedLineProperty.__init__(self, card, data)
00933         if card:
00934             self.pid = card.field(1)
00935             self.mid = card.field(2)
00936             #print "pid = ",self.pid
00937 
00938             nFields = card.nFields()-1 # -1 for PBEAM field
00939 
00940             self.so  = ['YES'] ## @todo what are these values (so[0],xxb[0])???
00941             self.xxb = [0.]
00942             self.A   = [card.field(3) ]
00943             self.i1  = [card.field(4, 0.0) ]
00944             self.i2  = [card.field(5, 0.0) ]
00945             self.i12 = [card.field(6, 0.0) ]
00946             self.j   = [card.field(7, 0.0) ]
00947             self.nsm = [card.field(8, 0.0) ]
00948             self.c1  = [card.field(9, 0.0) ]
00949             self.c2  = [card.field(10, 0.0)]
00950             self.d1  = [card.field(11, 0.0)]
00951             self.d2  = [card.field(12, 0.0)]
00952             self.e1  = [card.field(13, 0.0)]
00953             self.e2  = [card.field(14, 0.0)]
00954             self.f1  = [card.field(15, 0.0)]
00955             self.f2  = [card.field(16, 0.0)]
00956 
00957             #fields = card.fields(0)
00958             #print "fieldsPBEAM = ",fields
00959             #fieldsMid = fields[16:]
00960             #print "fieldsMid = ",fieldsMid
00961 
00962             #fields = card.fields(9)
00963             #print ""
00964             #print "  nFields = ",nFields
00965             #nFields = card.nFields()-16 # 17+16 (leading + trailing fields)
00966             # counting continuation cards
00967             nMajor    = nFields // 16
00968             nLeftover = nFields %  16
00969             #print "  nMajor=%s nLeftover=%s" %(nMajor,nLeftover)
00970             if nLeftover == 0:
00971                 nMajor -= 1
00972 
00973             if nMajor == 0:
00974                 nMajor = 1
00975 
00976             x = (nMajor)*16+1
00977             if card.field(x) in ['YES', 'YESA', 'NO']: # there is no footer
00978                 nMajor += 1
00979                 x += 16
00980 
00981             #print "  nMajor = ",nMajor
00982             for nRepeated in xrange(1, nMajor):
00983                 #print "  adding a major"
00984                 nStart = nRepeated*16+1  # field 17 is the first possible so
00985                 propFields = card.fields(nStart, nStart+16)
00986                 #print "propFields = ",propFields
00987 
00988                 #print "  so = ",propFields[0]
00989                 if propFields[0] not in [None, 'YES', 'YESA', 'NO']:
00990                     msg = "SO=%s for PBEAM pid=%s" % (propFields[0], self.pid)
00991                     raise RuntimeError(msg)
00992                 self.so.append( propFields[0])
00993                 self.xxb.append(propFields[1])
00994                 self.A.append(  propFields[2])
00995                 self.i1.append( set_default_if_blank(propFields[3], 0.0))
00996                 self.i2.append( set_default_if_blank(propFields[4], 0.0))
00997                 self.i12.append(set_default_if_blank(propFields[5], 0.0))
00998                 self.j.append(  set_default_if_blank(propFields[6], 0.0))
00999                 self.nsm.append(set_default_if_blank(propFields[7], 0.0))
01000                 self.c1.append( set_default_if_blank(propFields[8], 0.0))
01001                 self.c2.append( set_default_if_blank(propFields[9], 0.0))
01002                 self.d1.append( set_default_if_blank(propFields[10], 0.0))
01003                 self.d2.append( set_default_if_blank(propFields[11], 0.0))
01004                 self.e1.append( set_default_if_blank(propFields[12], 0.0))
01005                 self.e2.append( set_default_if_blank(propFields[13], 0.0))
01006                 self.f1.append( set_default_if_blank(propFields[14], 0.0))
01007                 self.f2.append( set_default_if_blank(propFields[15], 0.0))
01008             #print("nRepeated = %s" %(nRepeated))
01009 
01010             # footer fields
01011             self.k1   = card.field(x, 1.0)
01012 
01013             if self.k1 in ['YES', 'YESA', 'NO']:
01014                 msg = 'error reading PBEAM card pid=%s' % (self.pid)
01015                 raise RuntimeError(msg)
01016             #print "  k1 = ",self.k1
01017             self.k2   = card.field(x+1, 1.0)
01018             self.s1   = card.field(x+2, 0.0)
01019             self.s2   = card.field(x+3, 0.0)
01020             self.nsia = card.field(x+4, 0.0)
01021             self.nsib = card.field(x+5, self.nsia)
01022             self.cwa  = card.field(x+6, 0.0)
01023             self.cwb  = card.field(x+7, self.cwa)
01024 
01025             self.m1a = card.field(x+8, 0.0)
01026             self.m2a = card.field(x+9, self.m1a)
01027             self.m1b = card.field(x+10, 0.0)
01028             self.m2b = card.field(x+11, self.m1b)
01029             self.n1a = card.field(x+12, 0.0)
01030             self.n2a = card.field(x+13, self.n1a)
01031             self.n1b = card.field(x+14, 0.0)
01032             self.n2b = card.field(x+15, self.n1b)
01033         else:
01034             raise NotImplementedError('not supported')
01035         ###
01036 
01037     #def Area(self):
01038     #    """@warning area field not supported fully on PBEAM card"""
01039     #    #raise RuntimeError(self.A[0])
01040     #    return self.A[0]
01041 
01042     #def Nsm(self):
01043     #    """@warning nsm field not supported fully on PBEAM card"""
01044     #    #raise RuntimeError(self.nsm[0])
01045     #    return self.nsm[0]
01046 
01047     def MassPerLength(self):
01048         """
01049         mass = L*(Area*rho+nsm)
01050         mass/L = Area*rho+nsm
01051         """
01052         rho  = self.Rho()
01053         massPerLs = []
01054         for (area, nsm) in izip(self.A, self.nsm):
01055             massPerLs.append(area*rho+nsm)
01056         massPerL = integratePositiveLine(self.xxb, massPerLs)
01057         return massPerL
01058 
01059     def crossReference(self, model):
01060         self.mid = model.Material(self.mid)
01061 
01062     def writeCodeAster(self): # PBEAM
01063         a  = self.Area()
01064         iy = self.I11()
01065         iz = self.I22()
01066         j  = self.J()
01067         msg = ''
01068         msg += "    POUTRE=_F(GROUP_MA='P%s', # PBEAM\n" % (self.pid)
01069         msg += "              SECTION='GENERALE',\n"
01070         msg += "              CARA=('A','IY','IZ','JX'), # area, moments of inertia\n"
01071         msg += "              VALE=(%g,  %g,  %g,  %g),\n"  % (a, iy, iz, j)
01072 
01073         msg += "              ORIENTATION=_F( \n"
01074         msg += "                  CARA=('VECT_Y'), # direction of beam ???\n" # @todo is this correct
01075         msg += "                  VALE=(1.0,0.0,0.0,)"
01076         
01077         if [self.n1a, self.n1b] != [0., 0.]:
01078             msg += "              \n),\n"
01079             msg += "              CARA=('AX','AY'), # shear centers\n"
01080             msg += "              VALE=(%g, %g),\n"  % (self.n1a, self.n1b)
01081             msg += "             ),\n"
01082         else:
01083             msg += " )),\n"
01084         return (msg)
01085 
01086     def rawFields(self):
01087         fields = ['PBEAM', self.pid, self.Mid()]
01088 
01089         for (so, xxb, A, i1, i2, i12, j, nsm, c1, c2, d1, d2, e1, e2,
01090              f1, f2) in izip(self.so, self.xxb, self.A, self.i1, self.i2,
01091             self.i12, self.j, self.nsm, self.c1, self.c2, self.d1, self.d2,
01092             self.e1, self.e2, self.f1, self.f2):
01093             fields += [so, xxb, A, i1, i2, i12, j, nsm, c1, c2, d1, d2,
01094                        e1, e2, f1, f2]
01095         ###
01096         footer = [self.k1, self.k2, self.s1, self.s2, self.nsia, self.nsib,
01097                   self.cwa, self.cwb, self.m1a, self.m2a, self.m1b, self.m2b,
01098                   self.n1a, self.n2a, self.n1b, self.n2b]
01099         fields += footer
01100         return fields
01101 
01102     def reprFields(self):
01103         fields = ['PBEAM', self.pid, self.Mid()]
01104 
01105         i = 0
01106         for (so,xxb,A,i1,i2,i12,j,nsm,c1,c2,d1,d2,e1,e2,f1,f2) in izip(
01107             self.so,self.xxb,self.A,self.i1,self.i2,self.i12,self.j,self.nsm,
01108             self.c1,self.c2,self.d1,self.d2,self.e1,self.e2,self.f1,self.f2):
01109 
01110             i1  = set_blank_if_default(i1, 0.0)
01111             i2  = set_blank_if_default(i2, 0.0)
01112             i12 = set_blank_if_default(i12, 0.0)
01113             j   = set_blank_if_default(j, 0.0)
01114 
01115             nsm = set_blank_if_default(nsm, 0.0)
01116             c1 = set_blank_if_default(c1, 0.0)
01117             d1 = set_blank_if_default(d1, 0.0)
01118             e1 = set_blank_if_default(e1, 0.0)
01119             f1 = set_blank_if_default(f1, 0.0)
01120 
01121             c2 = set_blank_if_default(c2, 0.0)
01122             d2 = set_blank_if_default(d2, 0.0)
01123             e2 = set_blank_if_default(e2, 0.0)
01124             f2 = set_blank_if_default(f2, 0.0)
01125 
01126             #print "  i = ",i
01127             if i == 0: # the 1st 2 fields aren't written
01128                 fields +=          [A, i1, i2, i12, j, nsm, c1, c2, d1, d2,
01129                                     e1, e2, f1,f2]
01130             else:
01131                 fields += [so, xxb, A, i1, i2, i12, j, nsm, c1, c2, d1, d2,
01132                                     e1, e2, f1, f2]
01133             i += 1
01134         k1 = set_blank_if_default(self.k1, 1.0)
01135         k2 = set_blank_if_default(self.k2, 1.0)
01136         s1 = set_blank_if_default(self.s1, 0.0)
01137         s2 = set_blank_if_default(self.s2, 0.0)
01138         
01139         nsia = set_blank_if_default(self.nsia, 0.0)
01140         nsib = set_blank_if_default(self.nsib, self.nsia)
01141 
01142         cwa = set_blank_if_default(self.cwa, 0.0)
01143         cwb = set_blank_if_default(self.cwb, self.cwa)
01144 
01145         m1a = set_blank_if_default(self.m1a, 0.0)
01146         m2a = set_blank_if_default(self.m2a, self.m1a)
01147         m1b = set_blank_if_default(self.m1b, 0.0)
01148         m2b = set_blank_if_default(self.m2b, self.m1b)
01149 
01150         #print "m1a=%s m2a=%s" %(m1a,m2a)
01151         #print "m1b=%s m2b=%s" %(m1b,m2b)
01152 
01153         n1a = set_blank_if_default(self.n1a, 0.0)
01154         n2a = set_blank_if_default(self.n2a, self.n1a)
01155         n1b = set_blank_if_default(self.n1b, 0.0)
01156         n2b = set_blank_if_default(self.n2b, self.n1b)
01157         #print "n1a=%s n2a=%s" %(n1a,n2a)
01158         #print "n1b=%s n2b=%s" %(n1b,n2b)
01159 
01160         footer = [k1, k2, s1, s2, nsia, nsib, cwa, cwb,
01161                   m1a, m2a, m1b, m2b, n1a, n2a, n1b, n2b]
01162         
01163         #if footer == [self.k1,None,None,None,None,None,None,None,   None,None,None,None,None,None,None,None]:
01164         #    footer = []
01165         fields += footer
01166         #print fields
01167         return fields
01168         
01169 class PBEAML(IntegratedLineProperty):
01170     type = 'PBEAML'
01171     validTypes = {
01172         "ROD"   : 1, 
01173         "TUBE"  : 2,
01174         "L"     : 4,
01175         "I"     : 6,
01176         "CHAN"  : 4,
01177         "T"     : 4,
01178         "BOX"   : 4,
01179         "BAR"   : 2,
01180         "CROSS" : 4,
01181         "H"     : 4,
01182         "T1"    : 4,
01183         "I1"    : 4,
01184         "CHAN1" : 4,
01185         "Z"     : 4,
01186         "CHAN2" : 4,
01187         "T2"    : 4,
01188         "BOX1"  : 6,
01189         "HEXA"  : 3,
01190         "HAT"   : 4,
01191         "HAT1"  : 5,
01192         "DBOX"  : 10, # was 12
01193         } # for GROUP="MSCBML0"
01194     def __init__(self, card=None, data=None):
01195         IntegratedLineProperty.__init__(self, card, data)
01196         if card:
01197             self.pid   = card.field(1)
01198             self.mid   = card.field(2)
01199             self.group = card.field(3, 'MSCBMLO')
01200             self.Type  = card.field(4)
01201 
01202             nDim = self.validTypes[self.Type]
01203             #nAll = nDim+1
01204 
01205             #nDim = len(self.dim)-1
01206             dimAll = card.fields(9)
01207             
01208             self.dim = []
01209             Dim = []
01210             self.xxb = [0.]
01211             self.so = ['YES']
01212             self.nsm = []
01213             
01214             j = 0 # the dimension counter
01215             n = 0 # there is no SO or XXB for the first section (n=0)
01216             i = 9 # the index in the card
01217             #print "dimAll = ",dimAll,nDim,i
01218             for (ii, dim) in enumerate(dimAll): ## ii is the counter starting from 9
01219                 if j < nDim: # the first block, n=0 ???
01220                     #print "*1"
01221                     Dim.append(dim)
01222                     j += 1
01223                     i += 1
01224                 else: # other blocks, n>0 ???
01225                     #print "*2",
01226                     #print "dim = ",Dim
01227                     if isinstance(dim, str):
01228                         raise RuntimeError('nsm is a string...nsm=|%s|; fields=%s' %(dim,card.fields()))
01229                     self.nsm.append(dim)
01230                     if n > 0:
01231                         so  = card.field(i+1, 'YES')
01232                         xxb = card.field(i+2, 1.0  )
01233                         self.so.append( so) # dimAll[i+1]
01234                         self.xxb.append(xxb)  #dimAll[i+2]
01235                     #j = 
01236                     n += 1
01237                     i += 2
01238                     #print "Dim = ",Dim
01239                     self.dim.append(Dim)
01240                     Dim = []
01241                     j = 0
01242                 ###
01243                 #print("i=%s ii=%s j=%s Dim=%s" %(i, ii, j, Dim))
01244             ###
01245             if j <= nDim: # if the last field is blank
01246                 #print "DimB = ",Dim
01247                 self.dim.append(Dim)
01248                 self.nsm.append(0.0)
01249                 if isinstance(self.nsm[0], str):
01250                     msg = 'nsm is a string...nsm=|%s|' % (self.nsm)
01251                     raise RuntimeError(msg)
01252                 
01253             ###
01254             #print("nsm = %s" %(self.nsm))
01255             #print self
01256     
01257     def MassPerLength(self):
01258         """
01259         mass = L*(Area*rho+nsm)
01260         mass/L = Area*rho+nsm
01261         """
01262         rho  = self.Rho()
01263         massPerLs = []
01264         for (dim, nsm) in izip(self.dim, self.nsm):
01265             a = self.areaL(dim)
01266             try:
01267                 massPerLs.append(a*rho+nsm)
01268             except:
01269                 msg = "PBEAML a*rho+nsm a=%s rho=%s nsm=%s" % (a, rho, nsm)
01270                 raise RuntimeError(msg)
01271         massPerL = integratePositiveLine(self.xxb, massPerLs)
01272         return massPerL
01273 
01274     def Area(self):
01275         Areas = []
01276         for dim in self.dim:
01277             Areas.append(self.areaL(dim))
01278         A = integrateLine(self.xxb, Areas)
01279         return A
01280 
01281     #def Mid(self):
01282     #    return self.mid
01283 
01284     def crossReference(self, model):
01285         """
01286         @warning For structural problems, PBEAML entries must reference a MAT1 material entry
01287         @warning For heat-transfer problems, the MID must reference a MAT4 or MAT5 material entry.
01288         @note what happens when there are 2 subcases?
01289         """
01290         self.mid = model.Material(self.mid)
01291     
01292     def verify(self, model, iSubcase):
01293         if model.is_thermal_solution(iSubcase):
01294             assert self.mid.type in ['MAT4','MAT5']
01295         else:
01296             assert self.mid.type in ['MAT1']
01297         ###
01298     
01299     def _J(self):
01300         j = []
01301         for dims in self.dim:
01302             pass
01303             #print "dims = ",dims
01304             #IAreaL()
01305         return j
01306 
01307     def J(self):
01308         #Js = self._J()
01309         #j = integratePositiveLine(self.xxb, Js)
01310         j = None
01311         return j
01312 
01313     def I11(self):
01314         #i1 = integratePositiveLine(self.xxb,self.i1)
01315         i1 = None
01316         return i1
01317 
01318     def I22(self):
01319         #i2 = integratePositiveLine(self.xxb,self.i2)
01320         i2 = None
01321         return i2
01322 
01323     def I12(self):
01324         #i12 = integrateLine(self.xxb,self.i12)
01325         i12 = None
01326         return i12
01327 
01328     def writeCodeAster(self, iCut=0, iFace=0, iStart=0): # PBEAML
01329         msg = ''
01330         
01331         msg2 = 'Cut_%s = geompy.MakeCut(' % (iCut+1)
01332         for (xxb, so, dim, nsm) in izip(self.xxb, self.so, self.dim, self.nsm):
01333             msg  += self.CA_Section(iFace, iStart, self.dim)
01334             msg2 += 'Face_%i, ' % (iFace+1)
01335             iFace += 1
01336             iStart += len(self.dim)
01337         
01338         msg2 = msg2[-2:]
01339         msg2 += ')\n'
01340         
01341         msg2 += "geompy.addToStudy(Cut_%i,  'Cut_%i')\n"  % (iCut+1, iCut+1)
01342         iCut += 1
01343         return (msg+msg2, iCut, iFace, iStart)
01344 
01345     def rawFields(self):
01346         fields = ['PBEAML', self.pid, self.Mid(), self.group, self.Type, None, None, None, None]
01347         #print "self.nsm = ",self.nsm
01348         #print "xxb=%s so=%s dim=%s nsm=%s" %(self.xxb,self.so,self.dim,self.nsm)
01349         for (i, xxb, so, dim, nsm) in izip(count(), self.xxb, self.so, self.dim, self.nsm):
01350             if i == 0:
01351                 fields += dim+[nsm]
01352             else:
01353                 fields += [xxb, so]+dim+[nsm]
01354             ###
01355         ###
01356         #print self.printCard(fields)
01357         #raise NotImplementedError('verify PBEAML...')
01358         return fields
01359 
01360     def reprFields(self):
01361         group = set_blank_if_default(self.group, 'MSCBMLO')
01362         fields = self.rawFields()
01363         fields[3] = group
01364         return fields
01365 
01366 class PBEAM3(LineProperty): # not done, cleanup
01367     type = 'PBEAM3'
01368     def __init__(self, card=None, data=None):
01369         LineProperty.__init__(self, card, data)
01370         if card:
01371             self.pid = card.field(1)
01372             self.mid = card.field(2)
01373 
01374             self.A   = card.field(3)
01375             self.iz  = card.field(4)
01376             self.iy  = card.field(5)
01377             self.iyz = card.field(6, 0.0)
01378             self.j   = card.field(7, self.iy+self.iz)
01379             self.nsm = card.field(8, 0.0)
01380 
01381             self.cy = card.field(9)
01382             self.cz = card.field(10)
01383             self.dy = card.field(11)
01384             self.dz = card.field(12)
01385             self.ey = card.field(13)
01386             self.dz = card.field(14)
01387             self.fy = card.field(15)
01388             self.fz = card.field(16)
01389             
01390             
01391             # more...
01392         ###
01393         else:
01394             raise NotImplementedError('not implemented...')
01395         ###
01396 
01397     def Nsm(self):
01398         """@warning nsm field not supported fully on PBEAM3 card"""
01399         return self.nsm
01400 
01401     def crossReference(self, model):
01402         self.mid = model.Material(self.mid)
01403 
01404     def reprFields(self):
01405         raise NotImplementedError('not done...')
01406         fields = ['PBEAM3', self.pid, self.Mid(),] # other
01407         return fields
01408 
01409 class PBEND(LineProperty):
01410     type = 'PBEND'
01411     def __init__(self, card=None, data=None):
01412         LineProperty.__init__(self, card, data)
01413         if card:
01414             self.pid = card.field(1)
01415             self.mid = card.field(2)
01416 
01417             value3 = card.field(3)
01418             if isinstance(value3, float):
01419                 self.beamType = 1
01420                 ## Area of the beam cross section
01421                 self.A = card.field(3)
01422                 ## Area moments of inertia in planes 1 and 2.
01423                 self.i1 = card.field(4)
01424                 self.i2 = card.field(5)
01425                 ## Torsional stiffness
01426                 self.j = card.field(6)
01427 
01428                 # line2
01429                 ## The r,z locations from the geometric centroid for stress
01430                 ## data recovery.
01431                 self.c1 = card.field(9) 
01432                 self.c2 = card.field(10)
01433                 self.d1 = card.field(11)
01434                 self.d2 = card.field(12)
01435                 self.e1 = card.field(13)
01436                 self.e2 = card.field(14)
01437                 self.f1 = card.field(15)
01438                 self.f2 = card.field(16)
01439 
01440                 # line 3 
01441                 ## Shear stiffness factor K in K*A*G for plane 1 and plane 2.
01442                 self.k1 = card.field(17)
01443                 self.k2 = card.field(18)
01444                 ## Radial offset of the neutral axis from the geometric
01445                 ## centroid, positive is toward the center of curvature
01446                 self.deltaN = card.field(22)
01447 
01448             elif isinstance(value3, int):
01449                 self.beamType = 2
01450                 ## Flag selecting the flexibility and stress intensification
01451                 ## factors. See Remark 3. (Integer = 1, 2, or 3)
01452                 self.fsi = card.field(3)
01453                 ## Mean cross-sectional radius of the curved pipe
01454                 self.rm = card.field(4)
01455                 ## Wall thickness of the curved pipe
01456                 self.t = card.field(5)
01457                 ## Internal pressure
01458                 self.p = card.field(6)
01459                 
01460                 # line3
01461                 self.nsm = card.field(19)
01462                 self.rc  = card.field(20)
01463                 self.zc  = card.field(21)
01464             else:
01465                 raise RuntimeError('Area/FSI on CBEND must be defined...')
01466             ## Bend radius of the line of centroids
01467             self.rb = card.field(7)
01468             ## Arc angle of element  (optional)
01469             self.thetab = card.field(8)
01470 
01471             ## Nonstructural mass per unit length.
01472             self.nsm = card.field(19)
01473             ## Radial offset of the geometric centroid from points GA and GB
01474             self.rc = card.field(20)
01475             ## Offset of the geometric centroid in a direction perpendicular to the
01476             ## plane of points GA and GB and vector v
01477             self.zc = card.field(21)
01478         ###
01479         else:
01480             raise NotImplementedError('PBEND')
01481         ###
01482 
01483     #def Nsm(self):
01484         #"""@warning nsm field not supported fully on PBEND card"""
01485         #raise RuntimeError(self.nsm[0])
01486         #return self.nsm
01487 
01488     def crossReference(self, model):
01489         self.mid = model.Material(self.mid)
01490 
01491     def reprFields(self):
01492         fields = ['PBEND', self.pid, self.Mid(),] # other
01493         if self.beamType == 1:
01494             fields += [self.A, self.i1, self.i2, self.j, self.rb, self.thetab,
01495                        self.c1, self.c2, self.d1, self.d2, self.e1, self.e2, self.f1, self.f2,
01496                        self.k1, self.k2, self.nsm, self.rc, self.zc, self.deltaN]
01497         elif self.beamType == 2:
01498             fields += [self.fsi, self.rm, self.t, self.p, self.rb, self.thetab,
01499                        None, None, self.nsm, self.rc, self.zc]
01500         else:
01501             raise ValueError('only beamType=1 and 2 supported')
01502         return fields
01503 
 All Classes Namespaces Files Functions Variables