pyNastran  0.5.0
pyNastran BDF Reader/Writer, OP2 Parser, and GUI
damper.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 
00029 from pyNastran.bdf.cards.baseCard import Element
00030 
00031 
00032 class DamperElement(Element):
00033     def __init__(self, card, data):
00034         Element.__init__(self, card, data)
00035 
00036 class LineDamper(DamperElement):
00037     def __init__(self, card, data):
00038         DamperElement.__init__(self, card, data)
00039 
00040     def crossReference(self,mesh):
00041         self.nodes = mesh.Nodes(self.nodes)
00042         self.pid   = mesh.Property(self.pid)
00043 
00044 class CVISC(LineDamper):
00045     type = 'CVISC'
00046     def __init__(self,card=None,data=None):
00047         LineDamper.__init__(self, card, data)
00048         if card:
00049             self.eid = int(card.field(1))
00050             self.pid = int(card.field(2,self.eid))
00051             nids = card.fields(3,5)
00052         else:
00053             self.eid = data[0]
00054             self.pid = data[1]
00055             nids = data[2:4]
00056         ###
00057         self.prepareNodeIDs(nids)
00058         assert len(self.nodes)==2
00059     ###
00060 
00061     def B(self):
00062         return self.pid.ce
00063 
00064     def rawFields(self):
00065         fields = ['CVISC',self.eid,self.Pid()]+self.nodeIDs()
00066         return fields
00067 
00068     def reprFields(self):
00069         return self.rawFields()
00070 ###
00071 
00072 class CDAMP1(LineDamper):
00073     type = 'CDAMP1'
00074     def __init__(self,card=None,data=None):
00075         LineDamper.__init__(self, card, data)
00076         
00077         if card:
00078             self.eid = card.field(1)
00079             self.pid = card.field(2)
00080 
00081             nids = [card.field(3,0),card.field(5,0)]
00082 
00083             ## component number
00084             self.c1 = card.field(4,0)
00085             self.c2 = card.field(6,0)
00086         else:
00087             self.eid = data[0]
00088             self.pid = data[1]
00089             nids     = [data[2],data[4]]
00090             self.c1  = data[3]
00091             self.c2  = data[5]
00092         ###
00093         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)
00094         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)
00095         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00096         assert len(self.nodes)==2
00097 
00098     def isSameCard(self, elem, debug=False):
00099         if self.type!=elem.type:  return False
00100         fields1 = [self.eid,self.Pid()]+self.nodeIDs()+[self.c1,self.c2]
00101         fields2 = [elem.eid,elem.Pid()]+elem.nodeIDs()+[elem.c1,elem.c2]
00102         if debug:
00103             print("fields1=%s fields2=%s" %(fields1, fields2))
00104         return self.isSameFields(fields1,fields2)
00105 
00106     def B(self):
00107         return self.pid.b
00108 
00109     def crossReference(self,model):
00110         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00111         self.pid   = model.Property(self.pid)
00112         
00113     def rawFields(self):
00114         nodes = self.nodeIDs(allowEmptyNodes=True)
00115         fields = ['CDAMP1',self.eid,self.Pid(),nodes[0],self.c1,nodes[1],self.c2]
00116         return fields
00117 
00118 class CDAMP2(LineDamper):
00119     type = 'CDAMP2'
00120     def __init__(self,card=None,data=None):
00121         LineDamper.__init__(self, card, data)
00122         
00123         if card:
00124             self.eid = card.field(1)
00125 
00126             ## Value of the scalar damper (Real)
00127             self.b   = card.field(2)
00128 
00129             nids = [card.field(3,0),card.field(5,0)]
00130 
00131             ## component number
00132             self.c1 = card.field(4,0)
00133             self.c2 = card.field(6,0)
00134         else:
00135             self.eid = data[0]
00136             self.b   = data[1]
00137             nids     = [data[2],data[4]]
00138             self.c1  = data[3]
00139             self.c2  = data[5]
00140         ###
00141         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)
00142         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)
00143         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00144         assert len(self.nodes)==2
00145 
00146     def B(self):
00147         return self.b
00148 
00149     def crossReference(self,model):
00150         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00151         
00152     def rawFields(self):
00153         nodes = self.nodeIDs(allowEmptyNodes=True)
00154         fields = ['CDAMP2',self.eid,self.b,nodes[0],self.c1,nodes[1],self.c2]
00155         return fields
00156 
00157 class CDAMP3(LineDamper):
00158     type = 'CDAMP3'
00159     def __init__(self,card=None,data=None):
00160         LineDamper.__init__(self, card, data)
00161         
00162         if card:
00163             self.eid = card.field(1)
00164             self.pid = card.field(2)
00165             nids = [card.field(3,0),card.field(4,0)]
00166         else:
00167             self.eid = data[0]
00168             self.pid = data[1]
00169             nids     = [data[2],data[3]]
00170         ###
00171         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00172         assert len(self.nodes)==2
00173 
00174     def B(self):
00175         return self.pid.b
00176 
00177     def crossReference(self,model):
00178         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00179         self.pid   = model.Property(self.pid)
00180         
00181     def rawFields(self):
00182         nodes = self.nodeIDs(allowEmptyNodes=True)
00183         fields = ['CDAMP3',self.eid,self.pid,nodes[0],nodes[1]]
00184         return fields
00185 
00186 class CDAMP4(LineDamper):
00187     type = 'CDAMP4'
00188     def __init__(self,card=None,data=None):
00189         LineDamper.__init__(self, card, data)
00190         
00191         if card:
00192             self.eid = card.field(1)
00193             ## Value of the scalar damper (Real)
00194             self.b   = card.field(2)
00195             nids = [card.field(3,0),card.field(4,0)]
00196         else:
00197             self.eid = data[0]
00198             self.b   = data[1]
00199             nids     = [data[2],data[3]]
00200         ###
00201         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00202         assert len(self.nodes)==2
00203 
00204     def B(self):
00205         return self.b
00206 
00207     def crossReference(self,model):
00208         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00209         
00210     def rawFields(self):
00211         nodes = self.nodeIDs(allowEmptyNodes=True)
00212         fields = ['CDAMP4',self.eid,self.b,nodes[0],nodes[1]]
00213         return fields
00214 
00215 class CDAMP5(LineDamper):
00216     type = 'CDAMP5'
00217     def __init__(self,card=None,data=None):
00218         LineDamper.__init__(self, card, data)
00219         
00220         if card:
00221             self.eid = card.field(1)
00222             ## Property ID
00223             self.pid = card.field(2)
00224             nids = [card.field(3,0),card.field(4,0)]
00225         else:
00226             self.eid = data[0]
00227             self.pid = data[1]
00228             nids     = [data[2],data[3]]
00229         ###
00230         self.prepareNodeIDs(nids,allowEmptyNodes=True)
00231         assert len(self.nodes)==2
00232 
00233     def crossReference(self,model):
00234         self.nodes = model.Nodes(self.nodes,allowEmptyNodes=True)
00235         self.pid   = model.Property(self.pid)
00236         
00237     def rawFields(self):
00238         nodes = self.nodeIDs(allowEmptyNodes=True)
00239         fields = ['CDAMP5',self.eid,self.Pid(),nodes[0],nodes[1]]
00240         return fields
00241 
 All Classes Namespaces Files Functions Variables