pyNastran
0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
|
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