pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
springs.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 from __future__ import division, print_function
00028 import sys
00029 from numpy import matrix,zeros,dot,transpose
00030 from numpy.linalg import norm
00031 
00032 from pyNastran.bdf.fieldWriter import set_blank_if_default
00033 from pyNastran.bdf.cards.baseCard import Element
00034 
00035 class SpringElement(Element):
00036     def __init__(self, card, data):
00037         Element.__init__(self, card, data)
00038 
00039     def Length_noXref(self,n1=None,n2=None):
00040         """
00041         Returns the length of a bar/rod/beam element
00042         \f[ \large \sqrt{  (n_{x2}-n_{x1})^2+(n_{y2}-n_{y1})^2+(n_{z2}-n_{z1})^2  } \f]
00043         @param self the object pointer
00044         @param n1 a Node object (default=None)
00045         @param n2 a Node object (default=None)
00046         @note
00047             if n1 AND n2 are both none (the default), then the model must
00048             be cross-referenced already
00049         """
00050         #print self.type
00051         L = norm(n1.Position()-n2.Position())
00052         return L
00053 
00054     def Centroid(self):
00055         p = (self.nodes[1].Position()-self.nodes[0].Position())/2.
00056         return p
00057 
00058     def K(self):
00059         raise NotImplementedError('K not implemented in the '
00060                                   '%s class' % (self.type))
00061 
00062     def Lambda(self,model):
00063         """
00064         2d  [l,m,0,0]
00065             [0,0,l,m]
00066         
00067         3d  [l,m,n,0,0,0]
00068             [0,0,0,l,m,n]
00069         """
00070         is3D = False
00071         #R = self.Rmatrix(model,is3D)
00072         
00073         (n1,n2) = self.nodeIDs()
00074         p1 = model.Node(n1).Position()
00075         p2 = model.Node(n2).Position()
00076         v1 = p2-p1
00077         #print(v1)
00078         v1 = v1/norm(v1)
00079         (l,m,n) = v1
00080         if is3D:
00081             Lambda = matrix(zeros((2,6),'d')) # 3D
00082         else:
00083             Lambda = matrix(zeros((2,4),'d'))
00084 
00085         #print("R = \n",R)
00086         Lambda[0,0] = Lambda[1,2] = l
00087         Lambda[0,1] = Lambda[1,3] = m
00088 
00089         if is3D:
00090             Lambda[0,2] = Lambda[1,5] = n # 3D
00091         #print("Lambda = \n",Lambda)
00092         return Lambda
00093 
00094     def Stiffness(self,model):
00095         ki = self.K()
00096         k = ki*matrix([[1,-1,]
00097                        [-1, 1]])
00098 
00099         Lambda = self.Lambda(model)
00100         K = dot(dot(transpose(Lambda),k),Lambda)
00101         return K
00102 
00103     def Length(self):
00104         """
00105         Returns the length of a bar/rod/beam element
00106         \f[ \large \sqrt{  (n_{x2}-n_{x1})^2+(n_{y2}-n_{y1})^2+(n_{z2}-n_{z1})^2  } \f]
00107         @param self the object pointer
00108         @note
00109             the model must be cross-referenced already
00110         """
00111         #print self.type
00112         return self.Length_noXref(self.nodes[1],self.nodes[0])
00113 
00114     def Mass(self):
00115         return 0.0
00116 
00117     def reprFields(self):
00118         return self.rawFields()
00119 
00120     def __repr__(self):
00121         fields = self.rawFields()
00122         return self.printCard(fields)
00123 
00124 class CELAS1(SpringElement):
00125     type = 'CELAS1'
00126     asterType = 'CELAS1'
00127     def __init__(self,card=None,data=None):
00128         SpringElement.__init__(self, card, data)
00129         if card:
00130             self.eid = card.field(1)
00131 
00132             ## property ID
00133             self.pid = card.field(2,self.eid)
00134 
00135             nids = [card.field(3,0),card.field(5,0)]
00136             ## component number
00137             self.c1 = card.field(4,0)
00138             self.c2 = card.field(6,0)
00139 
00140         else:
00141             self.eid = data[0]
00142             self.pid = data[1]
00143             nids     = [data[2],data[3]]
00144             self.c1 = data[4]
00145             self.c2 = data[5]
00146         ###
00147         assert self.c1 in [0,1,2,3,4,5,6],'c1=|%s| on \n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' %(str(self),self.c1)
00148         assert self.c2 in [0,1,2,3,4,5,6],'c2=|%s| on \n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' %(str(self),self.c2)
00149         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00150         assert len(self.nodes)==2
00151 
00152     def isSameCard(self, elem, debug=False):
00153         if self.type!=elem.type:  return False
00154         fields1 = [self.eid]+self.nodes+[self.pid,self.c1,self.c2]
00155         fields2 = [elem.eid]+self.nodes+[elem.pid,elem.c1,elem.c2]
00156         if debug:
00157             print("fields1=%s fields2=%s" %(fields1, fields2))
00158         return self.isSameFields(fields1,fields2)
00159 
00160     def K(self):
00161         return self.pid.k
00162 
00163     def crossReference(self,model):
00164         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00165         self.pid   = model.Property(self.pid)
00166         
00167     def rawFields(self):
00168         nodes = self.nodeIDs(allowEmptyNodes=True)
00169         fields = ['CELAS1',self.eid,self.Pid(),nodes[0],self.c1,nodes[1],self.c2]
00170         return fields
00171 
00172 class CELAS2(SpringElement):
00173     type = 'CELAS2'
00174     asterType = 'CELAS2'
00175     def __init__(self,card=None,data=None):
00176         SpringElement.__init__(self, card, data)
00177         
00178         if card:
00179             self.eid = card.field(1)
00180 
00181             ## stiffness of the scalar spring
00182             self.k   = card.field(2)
00183 
00184             nids = [card.field(3,0),card.field(5,0)]
00185 
00186             ## component number
00187             self.c1 = card.field(4,0)
00188             self.c2 = card.field(6,0)
00189 
00190             ## damping coefficient
00191             self.ge = card.field(7,0.)
00192 
00193             ## stress coefficient
00194             self.s  = card.field(8,0.)
00195         else:
00196             self.eid = data[0]
00197             self.k   = data[1]
00198             nids     = [data[2],data[4]]
00199             self.c1  = data[3]
00200             self.c2  = data[5]
00201             self.ge  = data[6]
00202             self.s   = data[7]
00203         ###
00204         assert self.c1 in [0,1,2,3,4,5,6],'c1=|%s| on \n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' %(str(self),self.c1)
00205         assert self.c2 in [0,1,2,3,4,5,6],'c2=|%s| on \n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' %(str(self),self.c2)
00206         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00207         assert len(self.nodes)==2
00208 
00209     def isSameCard(self, elem, debug=False):
00210         if self.type!=elem.type:  return False
00211         fields1 = [self.eid]+self.nodes+[self.k,self.c1,self.c2]
00212         fields2 = [elem.eid]+self.nodes+[elem.k,elem.c1,elem.c2]
00213         if debug:
00214             print("fields1=%s fields2=%s" %(fields1, fields2))
00215         return self.isSameFields(fields1,fields2)
00216 
00217     def K(self):
00218         return self.k
00219 
00220     def crossReference(self,model):
00221         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00222         #print("nodes = ",self.nodes)
00223         
00224     def writeCodeAster(self):
00225         nodes = self.nodeIDs()
00226         msg = ''
00227         msg += 'DISCRET=_F( # CELAS2\n'
00228         if nodes[0]:
00229             msg += "     CARA='K_T_D_N'\n"
00230             msg += "     NOEUD=N%i,\n" %(nodes[0])
00231 
00232         if nodes[1]:
00233             msg += "     CARA='K_T_D_L'\n"
00234             msg += "     NOEUD=N%i,\n" %(nodes[1])
00235             msg += "     AMOR_HYST=%g # ge - damping\n" %(self.ge)
00236         msg += "     )\n"
00237         msg += "\n"
00238         
00239         if self.c1==1:
00240             msg += "VALE=(%g,0.,0.)\n" %(self.k)
00241         elif self.c1==2:
00242             msg += "VALE=(0.,%g,0.)\n" %(self.k)
00243         elif self.c1==2:
00244             msg += "VALE=(0.,0.,%g)\n" %(self.k)
00245         else:
00246             raise ValueError('unsupported value of c1=%s' %(self.c1))
00247         ###
00248         return msg
00249 
00250     def rawFields(self):
00251         nodes = self.nodeIDs(allowEmptyNodes=True,msg=str(['CELAS2',self.eid]))
00252         fields = ['CELAS2',self.eid,self.k,nodes[0],self.c1,nodes[1],self.c2,self.ge,self.s]
00253         return fields
00254 
00255     def reprFields(self):
00256         nodes = self.nodeIDs(allowEmptyNodes=True,msg=str(['CELAS2',self.eid]))
00257         ge = set_blank_if_default(self.ge,0.)
00258         s  = set_blank_if_default(self.s,0.)
00259         fields = ['CELAS2',self.eid,self.k,nodes[0],self.c1,nodes[1],self.c2,ge,s]
00260         return fields
00261 
00262 class CELAS3(SpringElement):
00263     type = 'CELAS3'
00264     asterType = 'CELAS3'
00265     def __init__(self,card=None,data=None):
00266         SpringElement.__init__(self, card, data)
00267 
00268         if card:
00269             #nids = [card.field(3),card.field(5)]
00270             #self.prepareNodeIDs(nids)
00271             #assert len(self.nodes)==2
00272 
00273             self.eid = card.field(1)
00274             ## property ID
00275             self.pid = card.field(2,self.eid)
00276 
00277             ## Scalar point identification numbers
00278             self.s1 = card.field(3,0)
00279             self.s2 = card.field(4,0)
00280         else:
00281             self.eid = data[0]
00282             self.pid = data[1]
00283             self.s1  = data[2]
00284             self.s2  = data[3]
00285         ###
00286 
00287     def isSameCard(self, elem, debug=False):
00288         if self.type!=elem.type:  return False
00289         fields1 = [self.eid,self.pid,self.s1,self.s2]
00290         fields2 = [elem.eid,elem.pid,elem.s1,elem.s2]
00291         if debug:
00292             print("fields1=%s fields2=%s" %(fields1, fields2))
00293         return self.isSameFields(fields1,fields2)
00294 
00295     def K(self):
00296         return self.pid.k
00297 
00298     def crossReference(self,model):
00299         self.nodes = model.Nodes(self.nodes)
00300         self.pid   = model.Property(self.pid)
00301     
00302     def rawFields(self):
00303         fields = ['CELAS3',self.eid,self.Pid(),self.s1,self.s2]
00304         return fields
00305 
00306     #def reprFields(self):
00307         #s1 = set_blank_if_default(self.s1,0)
00308         #s2 = set_blank_if_default(self.s2,0)
00309         #fields = ['CELAS3',self.eid,self.Pid(),s1,s2]
00310         #return fields
00311 
00312 class CELAS4(SpringElement):
00313     type = 'CELAS4'
00314     asterType = 'CELAS4'
00315     def __init__(self,card=None,data=None):
00316         SpringElement.__init__(self, card, data)
00317         
00318         if card:
00319             #nids = [card.field(3),card.field(5)]
00320             #self.prepareNodeIDs(nids)
00321             #assert len(self.nodes)==2
00322 
00323             self.eid = card.field(1)
00324 
00325             ## stiffness of the scalar spring
00326             self.k   = card.field(2)
00327 
00328             ## Scalar point identification numbers
00329             self.s1 = card.field(3,0)
00330             self.s2 = card.field(4,0)
00331         else:
00332             self.eid = data[0]
00333             self.k   = data[1]
00334             self.s1  = data[2]
00335             self.s2  = data[3]
00336         ###
00337 
00338     def isSameCard(self, elem, debug=False):
00339         if self.type!=elem.type:  return False
00340         fields1 = [self.eid,self.k,self.s1,self.s2]
00341         fields2 = [elem.eid,elem.k,elem.s1,elem.s2]
00342         if debug:
00343             print("fields1=%s fields2=%s" %(fields1, fields2))
00344         return self.isSameFields(fields1,fields2)
00345 
00346     def K(self):
00347         return self.k
00348 
00349     def crossReference(self,model):
00350         self.nodes = model.Nodes(self.nodes)
00351 
00352     def rawFields(self):
00353         fields = ['CELAS4',self.eid,self.k,self.s1,self.s2]
00354         return fields
00355 
00356     #def reprFields(self):
00357         #s1 = set_blank_if_default(self.s1,0)
00358         #s2 = set_blank_if_default(self.s2,0)
00359         #fields = ['CELAS4',self.eid,self.Pid(),s1,s2]
00360         #return fields
00361 
 All Classes Namespaces Files Functions Variables