def add_card(cls, card, comment=''): pid = integer(card, 1, 'pid') tkid = integer_or_blank(card, 2, 'tkid', 0) tgeid = integer_or_blank(card, 3, 'tgeid', 0) tknid = integer_or_blank(card, 4, 'tknid', 0) assert len(card) <= 5, 'len(PELAST card) = %i' % len(card) return PELAST(pid, tkid, tgeid, tknid, comment=comment)
def add(self, card, comment=''): cp0 = self.model.grdset.cp cd0 = self.model.grdset.cd ps0 = self.model.grdset.ps seid0 = self.model.grdset.seid i = self.i #: Node ID self.node_id[i] = integer(card, 1, 'nid') #: Grid point coordinate system self.cp[i] = integer_or_blank(card, 2, 'cp', cp0) x = double_or_blank(card, 3, 'x1', 0.) y = double_or_blank(card, 4, 'x2', 0.) z = double_or_blank(card, 5, 'x3', 0.) #: node location in local frame self.xyz[i] = [x, y, z] #: Analysis coordinate system self.cd[i] = integer_or_blank(card, 6, 'cd', cd0) #: SPC constraint self.ps[i] = integer_or_blank(card, 7, 'ps', ps0) #: Superelement ID self.seid[i] = integer_or_blank(card, 8, 'seid', seid0) self.i += 1
def test_integer_or_blank(self): """ value = integer_or_blank(card, n, fieldname) """ # integer self.check_integer(integer_or_blank) # float with self.assertRaises(SyntaxError): integer_or_blank(BDFCard([1.]), 0, 'field') with self.assertRaises(SyntaxError): integer_or_blank(BDFCard(['1.']), 0, 'field') # string with self.assertRaises(SyntaxError): integer_or_blank(BDFCard(['a']), 0, 'field') with self.assertRaises(SyntaxError): integer_or_blank(BDFCard(['1b']), 0, 'field') # blank self.assertEqual('a', integer_or_blank(BDFCard(['']), 0, 'field', 'a')) self.assertEqual('b', integer_or_blank(BDFCard([None]), 0, 'field', 'b')) card = [1, '2', '3.', 'C', None, ''] exact = [1, 2, SyntaxError, SyntaxError, None, None] default = [None, None, None, None, None, None] self.run_function_default(integer_or_blank, card, exact, default)
def add_card(cls, card, comment=''): mid = integer(card, 1, 'mid') tid = integer_or_blank(card, 2, 'tid') Type = string(card, 3, 'Type') if Type not in ['NLELAST', 'PLASTIC']: raise ValueError('MATS1 Type must be [NLELAST, PLASTIC]; Type=%r' % Type) if Type == 'NLELAST': # should we even read these? h = None hr = None yf = None limit1 = None limit2 = None #h = blank(card, 4, 'h') #hr = blank(card, 6, 'hr') #yf = blank(card, 5, 'yf') #limit1 = blank(card, 7, 'yf') #limit2 = blank(card, 8, 'yf') else: h = double_or_blank(card, 4, 'H') yf = integer_or_blank(card, 5, 'yf', 1) hr = integer_or_blank(card, 6, 'hr', 1) limit1 = double(card, 7, 'limit1') if yf in [3, 4]: limit2 = double(card, 8, 'limit2') else: #limit2 = blank(card, 8, 'limit2') limit2 = None assert len(card) <= 9, 'len(MATS1 card) = %i\ncard=%s' % (len(card), card) return MATS1(mid, tid, Type, h, hr, yf, limit1, limit2, comment=comment)
def __init__(self, card=None, data=None, comment=''): ThermalElement.__init__(self, card) if comment: self._comment = comment if card: #: Surface element ID number for a side of an #: element. (0 < Integer < 100,000,000) self.eid = integer(card, 1, 'eid') #: A heat conduction element identification self.eid2 = integer(card, 2, 'eid2') #: A consistent element side identification number #: (1 < Integer < 6) self.side = integer(card, 3, 'side') assert 0 < self.side < 7 #: A VIEW entry identification number for the front face self.iViewFront = integer_or_blank(card, 4, 'iViewFront', 0) #: A VIEW entry identification number for the back face self.iViewBack = integer_or_blank(card, 5, 'iViewBack', 0) #: RADM identification number for front face of surface element #: (Integer > 0) self.radMidFront = integer_or_blank(card, 6, 'radMidFront', 0) #: RADM identification number for back face of surface element #: (Integer > 0) self.radMidBack = integer_or_blank(card, 7, 'radMidBack', 0) assert len(card) <= 8, 'len(CHBDYE card) = %i' % len(card) else: raise NotImplementedError(data) self.grids = []
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) nids = [integer_or_blank(card, 3, 'n1', 0), integer_or_blank(card, 4, 'n2', 0)] assert len(card) <= 5, 'len(CVISC card) = %i\ncard=%s' % (len(card), card) return CVISC(eid, pid, nids, comment=comment)
def __init__(self, card, comment=''): ThermalElement.__init__(self, card) if comment: self._comment = comment #: Surface element ID self.eid = integer(card, 1, 'eid') # no field 2 #: Surface type self.Type = string(card, 3, 'Type') assert self.Type in ['REV', 'AREA3', 'AREA4', 'AREA6', 'AREA8'] #: A VIEW entry identification number for the front face self.iViewFront = integer_or_blank(card, 4, 'iViewFront', 0) #: A VIEW entry identification number for the back face self.iViewBack = integer_or_blank(card, 8, 'iViewBack', 0) #: RADM identification number for front face of surface element #: (Integer > 0) self.radMidFront = integer_or_blank(card, 6, 'radMidFront', 0) #: RADM identification number for back face of surface element #: (Integer > 0) self.radMidBack = integer_or_blank(card, 7, 'radMidBack', 0) # no field 8 #: Grid point IDs of grids bounding the surface (Integer > 0) self.nodes = [] n = 1 for i in range(9, len(card)): grid = integer_or_blank(card, i, 'grid%i' % n) if grid is not None: self.nodes.append(grid) assert len(self.nodes) > 0, 'card=%s' % card
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer(card, 2, 'pid') nids = [integer_or_blank(card, 3, 'n1', 0), integer_or_blank(card, 4, 'n2', 0)] assert len(card) <= 5, 'len(CDAMP5 card) = %i' % len(card) return CDAMP5(eid, pid, nids, comment=comment)
def add_card(cls, card, comment=''): name = string(card, 1, 'name') #zero #: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m) ifo = integer(card, 3, 'ifo') #: 1-Real, Single Precision; 2=Real,Double Precision; # 3=Complex, Single; 4=Complex, Double tin = integer(card, 4, 'tin') #: 0-Set by cell precision tout = integer_or_blank(card, 5, 'tout', 0) #: Input format of Ai, Bi. (Integer=blank or 0 indicates real, imaginary format; #: Integer > 0 indicates amplitude, phase format.) polar = integer_or_blank(card, 6, 'polar', 0) if ifo == 1: # square ncols = integer_or_blank(card, 8, 'ifo=%s; ncol' % (ifo)) elif ifo == 6: # symmetric ncols = integer_or_blank(card, 8, 'ifo=%s; ncol' % (ifo)) elif ifo in [2, 9]: # rectangular ncols = integer(card, 8, 'ifo=%s; ncol' % (ifo)) else: # technically right, but nulling this will fix bad decks #self.ncols = blank(card, 8, 'ifo=%s; ncol' % self.ifo) raise NotImplementedError('ifo=%s is not supported' % ifo) GCj = [] GCi = [] Real = [] Complex = [] return cls(name, ifo, tin, tout, polar, ncols, GCj, GCi, Real, Complex, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) s1 = integer_or_blank(card, 3, 's1') s2 = integer_or_blank(card, 4, 's2') assert len(card) <= 5, 'len(CMASS3 card) = %i' % len(card) return CMASS3(eid, pid, s1, s2, comment=comment)
def build(self): cards = self._cards ncards = len(cards) self.n = ncards if ncards: float_fmt = self.model.float_fmt self.nid = zeros(ncards, 'int32') self.temp = zeros(ncards, float_fmt) for i, card in enumerate(cards): #: Node ID self.nid[i] = integer(card, 1, 'nid') #: Grid point coordinate system self.cp[i] = integer_or_blank(card, 2, 'cp', cp0) x = double_or_blank(card, 3, 'x1', 0.) y = double_or_blank(card, 4, 'x2', 0.) z = double_or_blank(card, 5, 'x3', 0.) #: node location in local frame self.xyz[i] = [x, y, z] #: Analysis coordinate system self.cd[i] = integer_or_blank(card, 6, 'cd', cd0) #: SPC constraint self.ps[i] = integer_or_blank(card, 7, 'ps', ps0) #: Superelement ID self.seid[i] = integer_or_blank(card, 8, 'seid', seid0)
def add(self, card, comment=''): i = self.i self.element_id[i] = integer(card, 1, 'element_id') self.property_id[i] = integer(card, 2, 'property_id') self.coord_id[i] = integer_or_blank(card, 3, 'cp', 0) self.nspan[i] = integer_or_blank(card, 4, 'nspan', 0) self.nchord[i] = integer_or_blank(card, 5, 'nchord', 0) #if self.nspan==0: self.lspan[i] = integer_or_blank(card, 6, 'lspan', 0) #if self.nchord==0: self.lchord[i] = integer_or_blank(card, 7, 'lchord', 0) self.igid[i] = integer(card, 8, 'igid') self.p1[i, :] = [double_or_blank(card, 9, 'x1', 0.0), double_or_blank(card, 10, 'y1', 0.0), double_or_blank(card, 11, 'z1', 0.0)] self.x12[i] = double_or_blank(card, 12, 'x12', 0.) self.p4[i, :] = [double_or_blank(card, 13, 'x4', 0.0), double_or_blank(card, 14, 'y4', 0.0), double_or_blank(card, 15, 'z4', 0.0)] self.x43[i] = double_or_blank(card, 16, 'x43', 0.) assert len(card) <= 17, 'len(CAERO1 card) = %i\ncard=%s' % (len(card), card) self.i += 1
def add_card(cls, card, comment=''): pid = integer(card, 1, 'pid') mid1 = integer_or_blank(card, 2, 'mid1') t = double_or_blank(card, 3, 't') mid2 = integer_or_blank(card, 4, 'mid2') twelveIt3 = double_or_blank(card, 5, '12*I/t^3', 1.0) # poor name mid3 = integer_or_blank(card, 6, 'mid3') tst = double_or_blank(card, 7, 'ts/t', 0.833333) nsm = double_or_blank(card, 8, 'nsm', 0.0) if t is not None: t_over_2 = t / 2. z1 = double_or_blank(card, 9, 'z1', -t_over_2) z2 = double_or_blank(card, 10, 'z2', t_over_2) else: z1 = double_or_blank(card, 9, 'z1') z2 = double_or_blank(card, 10, 'z2') mid4 = integer_or_blank(card, 11, 'mid4') #if self.mid2 is None: # assert self.mid3 is None #else: # mid2 is defined # #print (self.mid2 = ", self.mid2) # assert self.mid2 >= -1 # #assert self.mid3 > 0 #if self.mid1 is not None and self.mid2 is not None: # assert self.mid4 == None assert len(card) <= 12, 'len(PSHELL card) = %i' % len(card) return PSHELL(pid, mid1, t, mid2, twelveIt3, mid3, tst, nsm, z1, z2, mid4, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') k = double(card, 2, 'k') s1 = integer_or_blank(card, 3, 's1', 0) s2 = integer_or_blank(card, 4, 's2', 0) assert len(card) <= 5, 'len(CELAS4 card) = %i\ncard=%s' % (len(card), card) return CELAS4(eid, k, s1, s2, comment=comment)
def add_card(self, card, comment=''): pid = integer(card, 1, 'property_id') if comment: self.set_comment(pid, comment) i = self.i self.property_id[i] = pid self.thickness[i] = double(card, 3, 'thickness') self.twelveIt3[i] = double_or_blank(card, 5, '12*I/t^3', 1.0) self.tst[i] = double_or_blank(card, 7, 'ts/t', 0.833333) self.nsm[i] = double_or_blank(card, 8, 'nsm', 0.0) t_over_2 = self.thickness[i] / 2. self.z1[i] = double_or_blank(card, 9, 'z1', -t_over_2) self.z2[i] = double_or_blank(card, 10, 'z2', t_over_2) self.material_ids[i, :] = [ integer(card, 2, 'material_id'), integer_or_blank(card, 4, 'material_id2', -1), integer_or_blank(card, 6, 'material_id3', -1), integer_or_blank(card, 11, 'material_id4', -1) ] #self.model.log.debug(self.material_ids[i, :]) #ii = np.array([i]) #file_obj = StringIO() #file_obj.write('<PSHELL object> n=%s\n' % self.n) #self.write_card_by_index(file_obj, i=ii) #print(file_obj.getvalue()) assert len(card) <= 12, 'len(PSHELL card) = %i\ncard=%s' % (len(card), card) self.i += 1
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) ga = integer(card, 3, 'ga') gb = integer(card, 4, 'gb') gc = integer(card, 5, 'gc') x, g0 = cls._init_x_g0(card, eid) wa = np.array([double_or_blank(card, 9, 'w1a', 0.0), double_or_blank(card, 10, 'w2a', 0.0), double_or_blank(card, 11, 'w3a', 0.0)], dtype='float64') wb = np.array([double_or_blank(card, 12, 'w1b', 0.0), double_or_blank(card, 13, 'w2b', 0.0), double_or_blank(card, 14, 'w3b', 0.0)], dtype='float64') wc = np.array([double_or_blank(card, 15, 'w1c', 0.0), double_or_blank(card, 16, 'w2c', 0.0), double_or_blank(card, 17, 'w3c', 0.0)], dtype='float64') tw = np.array([double_or_blank(card, 18, 0., 'twa'), double_or_blank(card, 19, 0., 'twb'), double_or_blank(card, 20, 0., 'twc')], dtype='float64') s = np.array([integer_or_blank(card, 21, 'sa'), integer_or_blank(card, 22, 'sb'), integer_or_blank(card, 23, 'sc')], dtype='float64') assert len(card) <= 24, 'len(CBEAM3 card) = %i\ncard=%s' % (len(card), card) return CBEAM3(eid, pid, ga, gb, gc, x, g0, wa, wb, wc, tw, s, comment='')
def add_card(cls, card, comment=''): #: Property ID pid = integer(card, 1, 'pid') #: Material ID mid1 = integer_or_blank(card, 2, 'mid1', 0) t1 = double_or_blank(card, 3, 't1') mid2 = integer_or_blank(card, 4, 'mid2', 0) if mid2 > 0: i = double(card, 5, 'i') assert i > 0.0 else: i = blank(card, 5, 'i') mid3 = integer(card, 6, 0) if mid3 > 0: t2 = double(card, 7, 't3') assert t2 > 0.0 else: t2 = blank(card, 7, 't3') nsm = double(card, 8, 'nsm') z1 = double(card, 9, 'z1') z2 = double(card, 10, 'z2') j = 1 phi = [] for i in range(11, len(card)): phii = double(card, i, 'phi' % j) phi.append(phii) j += 1 return PCONEAX(pid, mid1, t1, mid2, i, mid3, t2, nsm, z1, z2, phi, comment=comment)
def add(self, card, comment=''): self._comment = comment self.n = 1 self.cp = integer_or_blank(card, 2, 'cp', 0) self.cd = integer_or_blank(card, 6, 'cd', 0) self.ps = integer_or_blank(card, 7, 'ps', -1) self.seid = integer_or_blank(card, 8, 'seid', 0)
def _read_shock(self, card, istart): """ F(u, v) = Cv * S(u) * sign(v) * |v|^ev """ self.shockType = string_or_blank(card, istart + 1, 'shockType') self.shockCVT = double(card, istart + 2, 'shockCVT') self.shockCVC = double_or_blank(card, istart + 3, 'shockCVC') self.shockExpVT = double_or_blank(card, istart + 4, 'shockExpVT', 1.0) self.shockExpVC = double_or_blank(card, istart + 5, 'shockExpVC', self.shockExpVT) if self.shockType == 'TABLE': pass # self.shockIDTS = integer(card, istart + 6, 'shockIDTS') # self.shockIDETS = blank(card, istart + 9, 'shockIDETS') # self.shockIDECS = blank(card, istart + 10, 'shockIDECS') # self.shockIDETSD = blank(card, istart + 11, 'shockIDETSD') # self.shockIDECSD = blank(card, istart + 12, 'shockIDECSD') elif self.shockType == 'EQUAT': self.shockIDTS = blank(card, istart + 6, 'shockIDTS') self.shockIDETS = integer(card, istart + 9, 'shockIDETS') self.shockIDECS = integer_or_blank(card, istart + 10, 'shockIDECS', self.shockIDETS) self.shockIDETSD = integer(card, istart + 11, 'shockIDETSD') self.shockIDECSD = integer_or_blank(card, istart + 11, 'shockIDECSD', self.shockIDETSD) #def DEquation(self): #if isinstance(self.dequation, int): #return self.dequation #return self.dequation.equation_id else: raise RuntimeError('Invalid shockType=%r on card\n%s' %(self.shockType, card)) istart += 8 return istart
def add_card(cls, card, comment=''): sid = integer(card, 1, 'sid') method = string_or_blank(card, 2, 'method', 'LAN') f1 = double_or_blank(card, 3, 'f1') f2 = double_or_blank(card, 4, 'f2') ne = integer_or_blank(card, 5, 'ne') if method not in cls.allowed_methods: msg = 'method=%s; allowed_methods=[%s]' % ( method, ', '.join(cls.allowed_methods)) raise ValueError(msg) if method == 'SINV': nd = integer_or_blank(card, 6, 'nd', 600) if method == 'INV': nd = integer_or_blank(card, 6, 'nd', 3 * ne) elif method in ['GIV', 'MGIV', 'HOU', 'MHOU']: nd = integer_or_blank(card, 6, 'nd', 0) else: nd = integer(card, 6, 'nd') norm = string_or_blank(card, 9, 'norm', 'MASS') if method == 'POINT': G = integer(card, 10, 'G') C = components(card, 11, 'C') else: G = blank(card, 10, 'G') C = blank(card, 11, 'C') assert len(card) <= 12, 'len(EIGR card) = %i\ncard=%s' % (len(card), card) return EIGR(sid, method, f1, f2, ne, nd, norm, G, C, comment=comment)
def add_card(self, card, comment=''): i = self.i self.element_id[i] = integer(card, 1, 'element_id') self.property_id[i] = integer(card, 2, 'property_id') print(card) self.node_ids[i, :] = [ integer(card, 3, 'n1'), integer(card, 4, 'n2'), integer(card, 5, 'n3'), integer(card, 6, 'n4'), integer_or_blank(card, 7, 'n5', 0), integer_or_blank(card, 8, 'n6', 0), integer_or_blank(card, 9, 'n7', 0), integer_or_blank(card, 10, 'n8', 0)] self.thickness[i, :] = [ double_or_blank(card, 11, 'T1', 1.0), double_or_blank(card, 12, 'T2', 1.0), double_or_blank(card, 13, 'T3', 1.0), double_or_blank(card, 14, 'T4', 1.0), ] #self.theta_mcid[i] = integer_double_or_blank(card, 15, 'theta_mcid', 0.0) self.zoffset[i] = double_or_blank(card, 16, 'zoffset', 0.0) self.t_flag[i] = integer_or_blank(card, 17, 'TFlag', 0) self.i += 1
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) s1 = integer_or_blank(card, 3, 's1', 0) s2 = integer_or_blank(card, 4, 's2', 0) assert len(card) <= 5, 'len(CELAS3 card) = %i\ncard=%s' % (len(card), card) return CELAS3(eid, pid, s1, s2, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) nids = [integer(card, 3, 'g1'), integer_or_blank(card, 5, 'g2', 0)] c1 = integer_or_blank(card, 4, 'c1', 0) c2 = integer_or_blank(card, 6, 'c2', 0) assert len(card) <= 7, 'len(CELAS1 card) = %i\ncard=%s' % (len(card), card) return CELAS1(eid, pid, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) ga = integer(card, 3, 'ga') gb = integer_or_blank(card, 4, 'gb') cid = integer_or_blank(card, 5, 'cid') assert len(card) <= 6, 'len(CBUSH1D card) = %i\ncard=%s' % (len(card), card) return CBUSH1D(eid, pid, ga, gb, cid, comment=comment)
def add_card(self, card, comment=""): i = self.i self.element_id[i] = integer(card, 1, "eid") self.property_id[i] = integer_or_blank(card, 2, "pid", self.element_id[i]) self.node_ids[i, :] = [integer(card, 3, "n1"), integer(card, 5, "n2")] self.components[i, :] = [integer_or_blank(card, 4, "c1", 0), integer_or_blank(card, 6, "c2", 0)] assert len(card) <= 7, "len(CELAS1 card) = %i\ncard=%s" % (len(card), card) self.i += 1
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) g1 = integer_or_blank(card, 3, 'g1') c1 = integer_or_blank(card, 4, 'c1') g2 = integer_or_blank(card, 5, 'g2') c2 = integer_or_blank(card, 6, 'c2') assert len(card) <= 7, 'len(CMASS1 card) = %i' % len(card) return CMASS1(eid, pid, g1, c1, g2, c2, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') mass = double_or_blank(card, 2, 'mass', 0.) g1 = integer_or_blank(card, 3, 'g1') c1 = integer_or_blank(card, 4, 'c1') g2 = integer_or_blank(card, 5, 'g2') c2 = integer_or_blank(card, 6, 'c2') assert len(card) <= 7, 'len(CMASS2 card) = %i' % len(card) return CMASS2(eid, mass, g1, c1, g2, c2, comment=comment)
def add_card(self, card, comment=''): i = self.i eid = integer(card, 1, 'element_id') self.element_id[i] = eid self.property_id[i] = integer_or_blank(card, 2, 'property_id', eid) self.node_ids[i] = [integer(card, 3, 'GA'), integer(card, 4, 'GB')] #--------------------------------------------------------- # x / g0 field5 = integer_double_or_blank(card, 5, 'x1_g0') if isinstance(field5, integer_types): self.is_g0[i] = True self.g0[i] = field5 elif isinstance(field5, float): self.is_g0[i] = False # TODO: why is this custom? x2_default = 0.0 x3_default = 0.0 x = array([field5, double_or_blank(card, 6, 'x2', x2_default), double_or_blank(card, 7, 'x3', x3_default)], dtype='float64') self.x[i, :] = x if norm(x) == 0.0: msg = 'G0 vector defining plane 1 is not defined on %s %s.\n' % (self.type, eid) msg += 'G0 = %s\n' % field5 msg += 'X = %s\n' % x msg += '%s' % card raise RuntimeError(msg) #else: #msg = ('field5 on %s (G0/X1) is the wrong type...eid=%s field5=%s ' #'type=%s' % (self.type, eid, field5, type(field5))) #raise RuntimeError(msg) #--------------------------------------------------------- #: Element coordinate system identification. A 0 means the basic #: coordinate system. If CID is blank (-1), then the element coordinate #: system is determined from GO or Xi. #: (default=blank=element-based) cid = integer_or_blank(card, 8, 'cid', -1) if cid is not None: self.cid[i] = cid #: Location of spring damper (0 <= s <= 1.0) self.s[i] = double_or_blank(card, 9, 's', 0.5) #: Coordinate system identification of spring-damper offset. See #: Remark 9. (Integer > -1; Default = -1, which means the offset #: point lies on the line between GA and GB self.ocid[i] = integer_or_blank(card, 10, 'ocid', -1) #: Components of spring-damper offset in the OCID coordinate system #: if OCID > 0. self.si[i, :] = [double_or_blank(card, 11, 's1'), double_or_blank(card, 12, 's2'), double_or_blank(card, 13, 's3')] assert len(card) <= 14, 'len(CBUSH card) = %i\ncard=%s' % (len(card), card) self.i += 1
def __init__(self, card=None, data=None, sol=None, comment=''): Method.__init__(self, card, data) if comment: self._comment = comment if card: #: Set identification number. (Unique Integer > 0) self.sid = integer(card, 1, 'sid') #: For vibration analysis: frequency range of interest. For #: buckling analysis: eigenvalue range of interest. See Remark 4. #: (Real or blank, -5 10e16 <= V1 < V2 <= 5.10e16) self.v1 = double_or_blank(card, 2, 'v1') self.v2 = double_or_blank(card, 3, 'v2') #: Number of roots desired self.nd = integer_or_blank(card, 4, 'nd') #: Diagnostic level. (0 < Integer < 4; Default = 0) self.msglvl = integer_or_blank(card, 5, 'msglvl', 0) #: Number of vectors in block or set. Default is machine dependent self.maxset = integer_or_blank(card, 6, 'maxset') #: Estimate of the first flexible mode natural frequency #: (Real or blank) self.shfscl = double_or_blank(card, 7, 'shfscl') #: Method for normalizing eigenvectors (Character: 'MASS' or 'MAX') self.norm = string_or_blank(card, 8, 'norm') option_values = [interpret_value(field) for field in card[9:]] self.options = [] self.values = [] for option_value in option_values: try: (option, value) = option_value.split('=') except AttributeError: msg = 'parsing EIGRL card incorrectly; option_values=%s\ncard=%s' % ( option_values, card) raise RuntimeError(msg) self.options.append(option) self.values.append(value) #: Method for normalizing eigenvectors if sol in [103, 115, 146]: # normal modes,cyclic normal modes, flutter self.norm = string_or_blank(card, 8, 'norm', 'MASS') elif sol in [105, 110, 111, 116]: # buckling, modal complex eigenvalues, # modal frequency response,cyclic buckling self.norm = string_or_blank(card, 8, 'norm', 'MAX') else: self.norm = string_or_blank(card, 8, 'norm') #assert len(card) <= 9, 'len(EIGRL card) = %i' % len(card) assert len(card) <= 10, 'len(EIGRL card) = %i' % len(card) #msg = 'norm=%s sol=%s' % (self.norm, sol) #assert self.norm in ['MASS', 'MAX'],msg #assert card.nFields()<9,'card = %s' %(card.fields(0)) else: raise NotImplementedError('EIGRL')
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') b = double(card, 2, 'b') nids = [integer_or_blank(card, 3, 'n1', 0), integer_or_blank(card, 5, 'n2', 0)] c1 = integer_or_blank(card, 4, 'c1', 0) c2 = integer_or_blank(card, 6, 'c2', 0) assert len(card) <= 7, 'len(CDAMP2 card) = %i\ncard=%s' % (len(card), card) return CDAMP2(eid, b, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''): """ Adds a CDAMP2 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ eid = integer(card, 1, 'eid') b = double(card, 2, 'b') nids = [ integer_or_blank(card, 3, 'n1', 0), integer_or_blank(card, 5, 'n2', 0) ] c1 = integer_or_blank(card, 4, 'c1', 0) c2 = integer_or_blank(card, 6, 'c2', 0) assert len(card) <= 7, 'len(CDAMP2 card) = %i\ncard=%s' % (len(card), card) return CDAMP2(eid, b, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''): seid = integer(card, 1, 'seid') psid = integer_or_blank(card, 2, 'psid', 0) nodes = [] i = 1 nfields = len(card) for ifield in range(3, nfields): nid = integer_string_or_blank(card, ifield, 'nid_%i' % i) if nid: i += 1 nodes.append(nid) assert len(card) >= 3, f'len(CSUPER card) = {len(card):d}\ncard={card}' return CSUPER(seid, psid, nodes, comment=comment)
def add_card(cls, card, comment=''): """ Adds a CTRAX3 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ eid = integer(card, 1, 'eid') pid = integer(card, 2, 'pid') nids = [ integer_or_blank(card, 3, 'n1'), integer_or_blank(card, 4, 'n2'), integer_or_blank(card, 5, 'n3'), ] theta = integer_double_or_blank(card, 6, 'theta', 0.0) assert len(card) <= 7, 'len(CTRAX3 card) = %i\ncard=%s' % (len(card), card) return CTRAX3(eid, pid, nids, theta=theta, comment=comment)
def add_card(cls, card, comment=''): """ Adds a QVECT card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ sid = integer(card, 1, 'sid') q0 = double(card, 2, 'q0') t_source = double_or_blank(card, 3, 't_source') ce = integer_or_blank(card, 4, 'ce', 0) vector_tableds = [ integer_double_or_blank(card, 5, 'e1_tabled1', 0.0), integer_double_or_blank(card, 6, 'e2_tabled2', 0.0), integer_double_or_blank(card, 7, 'e3_tabled3', 0.0), ] control_id = integer_or_blank(card, 8, 'control_id', 0) i = 1 eids = [] for ifield in range(9, len(card)): eid = integer_or_string(card, ifield, 'eid_%i' % i) eids.append(eid) assert eid != 0, card i += 1 elements = expand_thru_by(eids) return QVECT(sid, q0, elements, t_source=t_source, ce=ce, vector_tableds=vector_tableds, control_id=control_id, comment=comment)
def _read_spring(card, istart): """ F(u) = Ft(u) """ spring_type = string_or_blank(card, istart + 1, 'springType') spring_idt = integer(card, istart + 2, 'springIDT') if spring_type == 'TABLE': spring_idc = blank(card, istart + 3, 'springIDC') spring_idtdu = blank(card, istart + 4, 'springIDTDU') spring_idcdu = blank(card, istart + 5, 'springIDCDU') elif spring_type == 'EQUAT': spring_idc = integer_or_blank(card, istart + 3, 'springIDC', spring_idt) spring_idtdu = integer(card, istart + 4, 'springIDTDU') spring_idcdu = integer_or_blank(card, istart + 5, 'springIDCDU', spring_idtdu) else: msg = 'Invalid springType=%r on card\n%s' % (spring_type, card) raise RuntimeError(msg) return spring_type, spring_idt, spring_idc, spring_idtdu, spring_idcdu
def add_card(cls, card, comment=''): seid_a = integer(card, 1, 'seid_a') seid_b = integer(card, 2, 'seid_b') tol = double_or_blank(card, 3, 'tol', 1e-5) loc = string_or_blank(card, 4, 'loc', 'YES') fields = card[9:] if len(fields) < 2: assert len(card) >= 9, f'len(SECONCT card) = {len(card):d}\ncard={card}' assert len(fields) % 2 == 0, 'card=%s\nfields=%s' % (card, fields) if 'THRU' in fields: raise NotImplementedError(fields) #start_a = integer(card, 9, 'start_a') #thru_a = string(card, 10, 'thru_a') #end_a = integer(card, 11, 'end_a') #start_b = integer(card, 12, 'start_b') #thru_b = string(card, 13, 'thru_b') #end_b = integer(card, 14, 'end_b') #assert thru_a == 'THRU', thru_a #assert thru_b == 'THRU', thru_b #nodes_a = list(range(start_a+1, end_a+1)) #nodes_b = list(range(start_b+1, end_b+1)) #print(nodes_a) else: nodes_a = [] nodes_b = [] inode = 1 for ifield in range(0, len(fields), 2): node_a = integer_or_blank(card, 9+ifield, 'node_a%i' % inode) node_b = integer_or_blank(card, 9+ifield+1, 'node_b%i' % inode) if node_a is None and node_b is None: continue assert node_a is not None, fields assert node_b is not None, fields nodes_a.append(node_a) nodes_b.append(node_b) inode += 1 return SECONCT(seid_a, seid_b, tol, loc, nodes_a, nodes_b, comment=comment)
def __init__(self, card, data, comment): """ Defines the CORD2x class :param card: a BDFCard object :param data: a list analogous to the card """ self.is_resolved = False Coord.__init__(self, card, data, comment) if card: #: coordinate system ID self.cid = integer(card, 1, 'cid') #: reference coordinate system ID self.rid = integer_or_blank(card, 2, 'rid', 0) #: origin in a point relative to the rid coordinate system self.e1 = array([double_or_blank(card, 3, 'e1x', 0.0), double_or_blank(card, 4, 'e1y', 0.0), double_or_blank(card, 5, 'e1z', 0.0)], dtype='float64') #: z-axis in a point relative to the rid coordinate system self.e2 = array([double_or_blank(card, 6, 'e2x', 0.0), double_or_blank(card, 7, 'e2y', 0.0), double_or_blank(card, 8, 'e2z', 0.0)], dtype='float64') #: a point on the xz-plane relative to the rid coordinate system self.e3 = array([double_or_blank(card, 9, 'e3x', 0.0), double_or_blank(card, 10, 'e3y', 0.0), double_or_blank(card, 11, 'e3z', 0.0)], dtype='float64') else: self.cid = data[0] self.rid = data[1] self.e1 = array(data[2:5], dtype='float64') self.e2 = array(data[5:8], dtype='float64') self.e3 = array(data[8:11], dtype='float64') assert len(data) == 11, 'data = %s' % (data) assert len(self.e1) == 3, self.e1 assert len(self.e2) == 3, self.e2 assert len(self.e3) == 3, self.e3 #: the global axes self.i = None self.j = None self.k = None if self.rid == 0: self.is_resolved = True self.setup()
def add_card(self, card, comment=''): i = self.i if comment: self.set_comment(mid, comment) self.material_id[i] = integer(card, 1, 'material_id') self.model.log.debug('add MATHP.material_id = %s' % self.material_id) a10 = double_or_blank(card, 2, 'a10', 0.) a01 = double_or_blank(card, 3, 'a01', 0.) self.a10[i] = a10 self.a01[i] = a01 self.d1[i] = double_or_blank(card, 4, 'd1', (a10 + a01) * 1000) self.rho[i] = double_or_blank(card, 5, 'rho', 0.) self.av[i] = double_or_blank(card, 6, 'av', 0.) self.tref[i] = double_or_blank(card, 7, 'tref', 0.) self.ge[i] = double_or_blank(card, 8, 'ge', 0.) self.na[i] = integer_or_blank(card, 10, 'na', 1) self.nd[i] = integer_or_blank(card, 11, 'nd', 1) self.a20[i] = double_or_blank(card, 17, 'a20', 0.) self.a11[i] = double_or_blank(card, 18, 'a11', 0.) self.a02[i] = double_or_blank(card, 19, 'a02', 0.) self.d2[i] = double_or_blank(card, 20, 'd2', 0.) self.a30[i] = double_or_blank(card, 25, 'a30', 0.) self.a21[i] = double_or_blank(card, 26, 'a21', 0.) self.a12[i] = double_or_blank(card, 27, 'a12', 0.) self.a03[i] = double_or_blank(card, 28, 'a03', 0.) self.d3[i] = double_or_blank(card, 29, 'd3', 0.) self.a40[i] = double_or_blank(card, 33, 'a40', 0.) self.a31[i] = double_or_blank(card, 34, 'a31', 0.) self.a22[i] = double_or_blank(card, 35, 'a22', 0.) self.a13[i] = double_or_blank(card, 36, 'a13', 0.) self.a04[i] = double_or_blank(card, 37, 'a04', 0.) self.d4[i] = double_or_blank(card, 38, 'd4', 0.) self.a50[i] = double_or_blank(card, 41, 'a50', 0.) self.a41[i] = double_or_blank(card, 42, 'a41', 0.) self.a32[i] = double_or_blank(card, 43, 'a32', 0.) self.a23[i] = double_or_blank(card, 44, 'a23', 0.) self.a14[i] = double_or_blank(card, 45, 'a14', 0.) self.a05[i] = double_or_blank(card, 46, 'a05', 0.) self.d5[i] = double_or_blank(card, 47, 'd5', 0.) self.tab1[i] = integer_or_blank(card, 49, 'tab1', 0) self.tab2[i] = integer_or_blank(card, 50, 'tab2', 0) self.tab3[i] = integer_or_blank(card, 51, 'tab3', 0) self.tab4[i] = integer_or_blank(card, 52, 'tab4', 0) self.tabd[i] = integer_or_blank(card, 56, 'tabd', 0) assert len(card) <= 57, 'len(MATHP card) = %i\ncard=%s' % (len(card), card) self.i += 1
def add_card(cls, card, comment=''): """ Adds a CFAST card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) Type = string(card, 3, 'Type') ida = integer(card, 4, 'ida') idb = integer(card, 5, 'idb') gs = integer_or_blank(card, 6, 'gs') ga = integer_or_blank(card, 7, 'ga') gb = integer_or_blank(card, 8, 'gb') xs = double_or_blank(card, 9, 'xs') ys = double_or_blank(card, 10, 'ys') zs = double_or_blank(card, 11, 'zs') assert len(card) <= 12, 'len(CFAST card) = %i\ncard=%s' % (len(card), card) #if self.Type=='PROP': # PSHELL/PCOMP ida & idb return CFAST(eid, pid, Type, ida, idb, gs=gs, ga=ga, gb=gb, xs=xs, ys=ys, zs=zs, comment=comment)
def _load_hess_inv(nrows, method, card): """loads inverse power""" alpha_omega_default = None LJ_default = None if method == 'INV': alpha_omega_default = 0.0 LJ_default = 1.0 alphaAjs = [] alphaBjs = [] omegaAjs = [] omegaBjs = [] #mblkszs = [] #iblkszs = [] #ksteps = [] LJs = [] NEJs = [] NDJs = [] for irow in range(nrows): NEj = integer_or_blank(card, 9 + 7 * irow + 5, 'NE%s' % str(irow), 0) NDJ_default = None if method == 'INV': NDJ_default = 3 * NEj i = 9 + 8 * irow alphaAjs.append( double_or_blank(card, i, 'alphaA' + str(irow), alpha_omega_default)) omegaAjs.append( double_or_blank(card, i + 1, 'omegaA' + str(irow), alpha_omega_default)) alphaBjs.append( double_or_blank(card, i + 2, 'alphaB' + str(irow), alpha_omega_default)) omegaBjs.append( double_or_blank(card, i + 3, 'omegaB' + str(irow), alpha_omega_default)) LJs.append( double_or_blank(card, i + 4, 'LJ' + str(irow), LJ_default)) NEJs.append(NEj) NDJs.append(integer_or_blank(card, i + 6, 'NDJ' + str(irow), NDJ_default)) return alphaAjs, omegaAjs, alphaBjs, omegaBjs, LJs, NEJs, NDJs
def add_card(cls, card, comment=''): """ Adds a SESET card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ seid = integer_or_blank(card, 1, 'seid', 0) ids = fields(integer_or_string, card, 'ID', i=2, j=len(card)) return SESET(seid, ids, comment=comment)
def add_card(cls, card, comment=''): """ Adds a CDAMP1 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ eid = integer(card, 1, 'eid') pid = integer_or_blank(card, 2, 'pid', eid) nids = [ integer_or_blank(card, 3, 'g1', 0), integer_or_blank(card, 5, 'g2', 0) ] #: component number c1 = integer_or_blank(card, 4, 'c1', 0) c2 = integer_or_blank(card, 6, 'c2', 0) assert len(card) <= 7, f'len(CDAMP1 card) = {len(card):d}\ncard={card}' return CDAMP1(eid, pid, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''): """ Adds a DMIG,UACCEL card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ tin = integer(card, 4, 'tin') ncol = integer_or_blank(card, 8, 'ncol') return DMIG_UACCEL(tin, ncol, load_sequences={}, comment=comment)
def add_card(cls, card, comment=''): """ Adds a LSEQ card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ sid = integer(card, 1, 'sid') excite_id = integer(card, 2, 'excite_id') load_id = integer_or_blank(card, 3, 'lid') temp_id = integer_or_blank(card, 4, 'tid') if load_id is None and temp_id is None: msg = 'LSEQ load_id/temp_id must not be None; load_id=%s temp_id=%s' % ( load_id, temp_id) raise RuntimeError(msg) assert len(card) <= 5, 'len(LSEQ card) = %i\ncard=%s' % (len(card), card) return LSEQ(sid, excite_id, load_id, tid=temp_id, comment=comment)
def add_card(cls, card, comment=''): """ Parameters ---------- card : BDFCard() a BDFCard object comment : str a comment for the card """ #: Grid point coordinate system blank(card, 1, 'blank') cp = integer_or_blank(card, 2, 'cp', 0) blank(card, 3, 'blank') blank(card, 4, 'blank') blank(card, 5, 'blank') cd = integer_or_blank(card, 6, 'cd', 0) ps = str(integer_or_blank(card, 7, 'ps', '')) seid = integer_or_blank(card, 8, 'seid', 0) assert len(card) <= 9, 'len(GRDSET card) = %i\ncard=%s' % (len(card), card) return GRDSET(cp, cd, ps, seid, comment=comment)
def add_card(self, card, comment=''): self.model.log.debug(' adding CTUBE') i = self.i eid = integer(card, 1, 'element_id') #if comment: #self.set_comment(eid, comment) self.element_id[i] = integer(card, 1, 'element_id') self.property_id[i] = integer_or_blank(card, 2, 'property_id', self.element_id[i]) self.node_ids[i] = [integer(card, 3, 'n1'), integer(card, 4, 'n2')] assert len(card) == 5, 'len(CTUBE card) = %i\ncard=%s' % (len(card), card) self.i += 1
def add_card(self, card, comment=''): i = self.i self.element_id[i] = integer(card, 1, 'element_id') self.property_id[i] = integer(card, 2, 'property_id') self.node_ids[i] = [ integer(card, 3, 'node_id1'), integer(card, 4, 'node_id2'), integer(card, 5, 'node_id3'), integer_or_blank(card, 6, 'node_id4', 0), integer_or_blank(card, 7, 'node_id5', 0), integer_or_blank(card, 8, 'node_id6', 0)] #self.theta_mcid[i] = integer_double_or_blank(card, 9, 'theta_mcid', 0.0) self.zoffset[i] = double_or_blank(card, 10, 'zoffset', 0.0) self.thickness[i] = [ double_or_blank(card, 11, 'T1', 1.0), double_or_blank(card, 12, 'T2', 1.0), double_or_blank(card, 13, 'T3', 1.0), ] self.t_flag[i] = integer_or_blank(card, 14, 'tflag', 0) assert len(card) <= 15, 'len(CTRIA6 card) = %i\ncard=%s' % (len(card), card) self.i += 1
def _load_clan(nrows, card): """loads complex Lanczos""" alphaAjs = [] omegaAjs = [] mblkszs = [] iblkszs = [] ksteps = [] NJIs = [] for irow in range(nrows): #NDJ_default = None i = 9 + 8 * irow alphaAjs.append(double_or_blank(card, i, 'alpha' + str(irow), 0.0)) omegaAjs.append( double_or_blank(card, i + 1, 'omega' + str(irow), 0.0)) mblkszs.append( double_or_blank(card, i + 2, 'mblock' + str(irow), 7)) iblkszs.append( integer_or_blank(card, i + 3, 'iblksz' + str(irow), 2)) ksteps.append(integer_or_blank(card, i + 4, 'kstep' + str(irow), 5)) NJIs.append(integer(card, i + 6, 'NJI' + str(irow))) return alphaAjs, omegaAjs, mblkszs, iblkszs, ksteps, NJIs
def add_card(cls, card, comment=''): sid = integer(card, 1, 'sid') qvol = double(card, 2, 'qvol') control_point = integer_or_blank(card, 3, 'control_id', 0) i = 1 eids = [] for ifield in range(4, len(card)): eid = integer_or_string(card, ifield, 'eid_%i' % i) eids.append(eid) i += 1 elements = expand_thru_by(eids) return QVOL(sid, qvol, control_point, elements, comment=comment)
def add_card(cls, card, comment=''): """ Adds a CELAS2 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ eid = integer(card, 1, 'eid') k = double(card, 2, 'k') nids = [ integer_or_blank(card, 3, 'g1', 0), integer_or_blank(card, 5, 'g2', 0) ] c1 = integer_or_blank(card, 4, 'c1', 0) c2 = integer_or_blank(card, 6, 'c2', 0) ge = double_or_blank(card, 7, 'ge', 0.) s = double_or_blank(card, 8, 's', 0.) assert len(card) <= 9, f'len(CELAS2 card) = {len(card):d}\ncard={card}' return CELAS2(eid, k, nids, c1, c2, ge, s, comment=comment)
def add_card(self, card, nPDAMP=0, comment=''): self.n = 1 #if comment: # self.comment = comment noffset = nPDAMP * 5 # 2 PDAMP properties can be defined on 1 PDAMP card # these are split into 2 separate cards pid = integer_or_blank(card, 1 + noffset, 'pid') if pid is not None: self._property_id.append(pid) self._B.append(double(card, 2 + noffset, 'b')) self._ge.append(double_or_blank(card, 3 + noffset, 'ge', 0.)) self._s.append(double_or_blank(card, 4 + noffset, 's', 0.))
def add_card(cls, card, comment=''): """ Adds a RFORCE1 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ sid = integer(card, 1, 'sid') nid = integer_or_blank(card, 2, 'nid', 0) cid = integer_or_blank(card, 3, 'cid', 0) scale = double_or_blank(card, 4, 'scale', 1.) r123 = [ double_or_blank(card, 5, 'r1', 1.), double_or_blank(card, 6, 'r2', 0.), double_or_blank(card, 7, 'r3', 0.), ] method = integer_or_blank(card, 8, 'method', 1) racc = double_or_blank(card, 9, 'racc', 0.) mb = integer_or_blank(card, 10, 'mb', 0) group_id = integer_or_blank(card, 11, 'group_id', 0) assert len(card) <= 12, 'len(RFORCE1 card) = %i\ncard=%s' % (len(card), card) return RFORCE1(sid, nid, scale, cid=cid, r123=r123, racc=racc, mb=mb, group_id=group_id, method=method, comment=comment)
def add_card(cls, card, comment=''): eid = integer(card, 1, 'eid') pconid = integer(card, 2, 'pconid') film_node = integer_or_blank(card, 3, 'film_node', 0) cntrlnd = integer_or_blank(card, 4, 'cntrlnd', 0) ta1 = integer(card, 5, 'TA1') assert ta1 > 0, ta1 ta2 = integer_or_blank(card, 6, 'ta2', ta1) ta3 = integer_or_blank(card, 7, 'ta3', ta1) ta4 = integer_or_blank(card, 8, 'ta4', ta1) ta5 = integer_or_blank(card, 9, 'ta5', ta1) ta6 = integer_or_blank(card, 10, 'ta6', ta1) ta7 = integer_or_blank(card, 11, 'ta7', ta1) ta8 = integer_or_blank(card, 12, 'ta8', ta1) ta = [ta1, ta2, ta3, ta4, ta5, ta6, ta7, ta8] assert len(card) <= 13, 'len(CONV card) = %i\ncard=%s' % (len(card), card) return CONV(eid, pconid, film_node, cntrlnd, ta, comment=comment)
def add_card(cls, card, comment=''): """ Adds a PDAMPT card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ pid = integer(card, 1, 'pid') tbid = integer_or_blank(card, 2, 'tbid', 0) assert len(card) <= 3, 'len(PDAMPT card) = %i\ncard=%s' % (len(card), card) return PDAMPT(pid, tbid, comment=comment)
def add_card(cls, card, comment=''): """ Adds a RFORCE card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ sid = integer(card, 1, 'sid') nid = integer_or_blank(card, 2, 'nid', 0) cid = integer_or_blank(card, 3, 'cid', 0) scale = double_or_blank(card, 4, 'scale', 1.) r1 = double_or_blank(card, 5, 'r1', 0.) r2 = double_or_blank(card, 6, 'r2', 0.) r3 = double_or_blank(card, 7, 'r3', 0.) method = integer_or_blank(card, 8, 'method', 1) racc = double_or_blank(card, 9, 'racc', 0.) mb = integer_or_blank(card, 10, 'mb', 0) idrf = integer_or_blank(card, 11, 'idrf', 0) assert len(card) <= 12, 'len(RFORCE card) = %i\ncard=%s' % (len(card), card) return RFORCE(sid, nid, cid, scale, r1, r2, r3, method, racc, mb, idrf, comment=comment)
def add_card(self, card, comment): i = self.i self.load_id[i] = integer(card, 1, 'sid') self.node_id[i] = integer(card, 2, 'node') self.coord_id[i] = integer_or_blank(card, 3, 'cid', 0) self.mag[i] = double(card, 4, 'mag') xyz = [ double_or_blank(card, 5, 'X1', 0.0), double_or_blank(card, 6, 'X2', 0.0), double_or_blank(card, 7, 'X3', 0.0) ] self.xyz[i] = xyz assert len(card) <= 8, 'len(FORCE card) = %i\ncard=%s' % (len(card), card) self.i += 1
def add_card(cls, card, comment=''): """ Adds a VIEW card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ iview = integer(card, 1, 'iview') icavity = integer(card, 2, 'icavity') shade = string_or_blank(card, 3, 'shade', default='BOTH') nbeta = integer_or_blank(card, 4, 'nbeta', default=1) ngamma = integer_or_blank(card, 5, 'ngamma', default=1) dislin = double_or_blank(card, 6, 'dislin', default=0.0) return VIEW(iview, icavity, shade=shade, nbeta=nbeta, ngamma=ngamma, dislin=dislin, comment=comment)
def add_card(cls, card, comment=''): """ Adds a TABLES1 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ table_id = integer(card, 1, 'tid') Type = integer_or_blank(card, 2, 'Type', 1) x, y = read_table(card, table_id, 'TABLES1') return TABLES1(table_id, x, y, Type=Type, comment=comment)
def add_card(cls, card, comment=''): """ Adds a RADLST card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ icavity = integer(card, 1, 'icavity') matrix_type = integer_or_blank(card, 2, 'matrix_type', 1) eids = fields(integer, card, 'eid', i=3, j=card.nfields) return RADLST(icavity, eids, matrix_type=matrix_type, comment=comment)
def get_spc_constraint(card, i): """parses an SPC/SPCD card""" if i == 0: constraint_id = integer(card, 1, 'sid') node_id = integer(card, 2, 'G1') dofs = components_or_blank(card, 3, 'C1', 0) enforced_motion = double_or_blank(card, 4, 'D1', 0.0) elif i == 1: constraint_id = integer(card, 1, 'sid') node_id = integer_or_blank(card, 5, 'G2') dofs = components_or_blank(card, 6, 'C2', 0) enforced_motion = double_or_blank(card, 7, 'D2', 0.0) else: raise RuntimeError('i =', i) return constraint_id, node_id, dofs, enforced_motion