def exportBlockTopology(self, name):
retval= bte.BlockData()
retval.name= name
counter= 0
for p in self.kPoints:
key= self.kPointsNames[counter]
retval.appendPoint(id= counter,x= p[0],y= p[1],z= p[2], labels= self.labelDict[key])
counter+= 1
counter= 0
for key in self.lines:
line= self.lines[key]
block= bte.BlockRecord(counter,'line',line,self.labelDict[key])
retval.appendBlock(block)
counter+= 1
for name in self.layersToImport:
fg= self.facesByLayer[name]
for key in fg:
face= fg[key]
block= bte.BlockRecord(counter,'face',face,self.labelDict[key])
retval.appendBlock(block)
counter+= 1
return retval
def getBoltedPointBlocks(gussetPlateBlocks, boltedPlateBlocks,
distBetweenPlates):
''' Return the points linked by bolts between the two pieces.
:param gussetPlateBlocks: blocks of the gusset plate.
:param boltedPlateBlocks: plate bolted to the gusset plate.
:param distBetweenPlates: distance between plates.
'''
retval = bte.BlockData()
gussetPlateBoltCenters = list()
for key in gussetPlateBlocks.points:
p = gussetPlateBlocks.points[key]
if (p.getAttribute('objType') == 'hole_center'):
gussetPlateBoltCenters.append(p)
boltedPlateBoltCenters = list()
for key in boltedPlateBlocks.points:
p = boltedPlateBlocks.points[key]
if (p.getAttribute('objType') == 'hole_center'):
boltedPlateBoltCenters.append(p)
tol = distBetweenPlates / 100.0
for pA in gussetPlateBoltCenters:
for pB in boltedPlateBoltCenters:
dist = math.sqrt((pA.coords[0] - pB.coords[0])**2 +
(pA.coords[1] - pB.coords[1])**2 +
(pA.coords[2] - pB.coords[2])**2)
if (abs(dist - distBetweenPlates) < tol):
boltBlk = bte.BlockRecord(id=-1,
typ='line',
kPoints=[pA.id, pB.id])
id = retval.appendBlock(boltBlk)
return retval
def getBasePlateBlocks(self, columnShapeBlocks, blockProperties=None):
''' Create the blocks corresponding to the baseplate.
:param columnShapeBlocks: blocks of the column welded to the baseplate.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
properties = bte.BlockProperties.copyFrom(blockProperties)
retval = bte.BlockData()
retval.extend(self.basePlate.getBlocks(blockProperties=properties))
flangeLegSize = math.floor(
self.basePlate.getFlangeWeldLegSize(0.3) *
1e3) / 1e3 # Arbitrary factor: temporary solution. LP 29/09/2020
webLegSize = math.floor(
self.basePlate.getWebWeldLegSize() *
1e3) / 1e3 # Default factor: temporary solution. LP 29/09/2020
columnBasePlateWeldBlocks = self.getColumnBaseplateWeldBlocks(
flangeLegSize, webLegSize, properties)
for face, weld in zip(columnShapeBlocks.faceBlocks,
columnBasePlateWeldBlocks.weldBlocks):
weldProperties = bte.BlockProperties.copyFrom(properties)
weldProperties.appendAttribute('ownerId', 'f' +
str(face.id)) # owner identifier.
weld.blockProperties += (weldProperties)
retval.extend(columnBasePlateWeldBlocks)
return retval
def getBlocks(self, blockProperties=None):
''' Creates the block data for later meshing.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
originNodeTag = str(self.originNode.tag)
properties = bte.BlockProperties.copyFrom(blockProperties)
properties.appendAttribute('jointId', originNodeTag)
retval = bte.BlockData()
# Column blocks.
columnShapeBlocks = self.getColumnShapeBlocks(
self.columnLengthFactor, blockProperties=properties)
retval.extend(columnShapeBlocks)
# Beam blocks.
beamShapeBlocks = self.getBeamShapeBlocks(self.beamLengthFactor,
blockProperties=properties)
retval.extend(beamShapeBlocks)
# Diagonal blocks.
for e in self.diagonals:
retval.extend(
self.getGussetBlocksForDiagonal(e, blockProperties=properties))
if (hasattr(self, 'basePlate')):
retval.extend(
self.getBasePlateBlocks(columnShapeBlocks,
blockProperties=properties))
else:
lmsg.warning('base plate not found.')
return retval
def getBlocks(self):
''' Creates the block data for meshing.'''
retval = bte.BlockData()
retval.name = self.name + '_blocks'
for c in self.connections:
retval.extend(c.getBlocks())
return retval
def exportBlockTopology(self, name):
retval= bte.BlockData()
retval.name= name
retval.fileName= self.fileName
retval.logMessage= '# imported from file: '+self.fileName+' on '
retval.logMessage+= str(datetime.datetime.now())
counter= 0
if(self.kPoints):
for p in self.kPoints:
key= self.kPointsNames[counter]
bp= bte.BlockProperties(labels= self.labelDict[key])
retval.appendPoint(id= counter,x= p[0],y= p[1],z= p[2], pointProperties= bp)
counter+= 1
counter= 0
for key in self.lines:
line= self.lines[key]
bp= bte.BlockProperties(labels= self.labelDict[key])
block= bte.BlockRecord(counter,'line',line, blockProperties= bp)
retval.appendBlock(block)
counter+= 1
for name in self.getNamesToImport():
fg= self.facesTree[name]
for key in fg:
face= fg[key]
bp= bte.BlockProperties(labels= self.labelDict[key])
block= bte.BlockRecord(counter,'face',face, blockProperties= bp)
retval.appendBlock(block)
counter+= 1
else:
lmsg.warning('Nothing to export.')
return retval
def getBeamShapeBlocks(self, factor, blockProperties=None):
''' Return the faces of the beams.
:param factor: factor multiplies the unary direction vector
of the member to define its extrusion
direction and lenght.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
beamShapeProperties = bte.BlockProperties.copyFrom(blockProperties)
beamShapeProperties.appendAttribute('objType', 'beam')
for b in self.beams:
webPlane = self.getColumnWebMidPlane()
angleWithWeb = webPlane.getAngleWithVector3d(b.iVector)
columnShape = self.getColumnShape()
columnHalfB = columnShape.getFlangeWidth() / 2.0
columnHalfH = columnShape.h() / 2.0
origin = self.getOrigin()
beamOrientation = b.getOrientation(origin)
if (abs(angleWithWeb) <
1e-3): # beam parallel to web => flange beam.
beam_label = 'flange_beam'
b.connectedTo = 'flange'
tf = columnShape.getFlangeThickness()
offset = (25e-3 + columnHalfH - tf / 2.0) * beamOrientation
else: # beam normal to web => web beam
beam_label = 'web_beam'
b.connectedTo = 'web'
offset = (20e-3 + columnHalfB) * beamOrientation
beamShapeProperties.appendAttribute('beamLabel', beam_label)
beamOrigin = origin + offset * b.iVector # beam direction
retval.extend(
b.getMemberBlocks(origin, beamOrigin, factor,
beamShapeProperties))
return retval
def getBlocks(self, blockProperties=None):
''' Return the block decomposition of the base plate.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
contour = self.getContour().getVertexList()
plateProperties = bte.BlockProperties.copyFrom(blockProperties)
plateProperties.appendAttribute('objType', 'baseplate')
points = list()
for p2d in contour:
points.append(geom.Pos3d(p2d.x, p2d.y, 0.0))
blk = retval.blockFromPoints(points,
plateProperties,
thickness=self.t,
matId=self.steel.name)
ownerId = 'f' + str(blk.id) # Hole owner.
boltGroup = 'joint_' + plateProperties.getAttribute(
'jointId') # Joint id.
boltGroup += '_' + plateProperties.getAttribute('objType')
holeProperties = bte.BlockProperties.copyFrom(plateProperties)
holeProperties.appendAttribute('boltGroup', boltGroup)
blk.holes = self.anchorGroup.getHoleBlocks(
self.getLocalRefSys(),
blockProperties=holeProperties,
ownerId=ownerId)
retval.extend(blk.holes)
return retval
def getGussetBlocks(self,
verticalWeldLegSize,
horizontalWeldLegSize,
blockProperties=None):
''' Return the blocks that define the gusset.
:param verticalWeldLegSize: leg size for the vertical welds.
:param horizontalWeldLegSize: leg size for the horizontal welds.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
gussetPlateProperties = bte.BlockProperties.copyFrom(blockProperties)
blk = retval.blockFromPoints(
self.contour,
blockProperties=gussetPlateProperties,
thickness=self.boltedPlateTemplate.thickness,
matId=self.boltedPlateTemplate.steelType.name)
holeProperties = bte.BlockProperties.copyFrom(blockProperties)
ownerId = 'f' + str(blk.id)
holeProperties.appendAttribute('ownerId', ownerId) # Hole owner id.
blk.holes = self.getHoleBlocks(
ownerId, blockProperties=holeProperties
) # Get the hole blocks for the new plate
retval.extend(blk.holes)
kPointIds = blk.getKPointIds()
blk.weldBlocks = self.getWeldBlocks(
ownerId, kPointIds, verticalWeldLegSize, horizontalWeldLegSize,
blockProperties) # Get the weld blocks for the new plate
retval.extend(blk.weldBlocks)
return retval
def getWeldBlocks(self,
ownerId,
kPointIds,
verticalWeldLegSize,
horizontalWeldLegSize,
blockProperties=None):
''' Return the blocks representing the welds.
:param ownerId: identifier of the face with the welds.
:param kPointIds: identifiers of the points at weld ends.
:param verticalWeldLegSize: leg size for the vertical welds.
:param horizontalWeldLegSize: leg size for the horizontal welds.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
weldProperties = bte.BlockProperties.copyFrom(blockProperties)
weldProperties.appendAttribute('objType', 'weld')
weldProperties.appendAttribute('ownerId', ownerId) # Weld owner id.
weldLinesIndexes = self.getWeldLinesIndexes(verticalWeldLegSize,
horizontalWeldLegSize)
for l in weldLinesIndexes:
pA = kPointIds[l[0]]
pB = kPointIds[l[1]]
weldLegSize = l[2]
weldProperties.appendAttribute('legSize', weldLegSize)
weldBlk = bte.BlockRecord(id=-1,
typ='line',
kPoints=[pA, pB],
blockProperties=weldProperties,
thk=None)
retval.appendBlock(weldBlk)
return retval
def getBeamShapeBlocks(self, factor, blockProperties=None):
''' Return the faces of the beams.
:param factor: factor multiplies the unary direction vector
of the member to define its extrusion
direction and lenght.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
beamBlocks = super(Connection, self).getBeamShapeBlocks(factor)
retval.extend(beamBlocks)
plateProperties = bte.BlockProperties.copyFrom(blockProperties)
plateProperties.appendAttribute('objType', 'flange_plate')
# Flange plates.
for b in self.beams:
flangePlate = b.getFlangeBoltedPlate(self.boltSteel)
origin = self.getOrigin()
print('origin: ', origin, ' beam origin: ', b.memberOrigin)
baseVectors = b.getDirection(origin)
halfH = (b.shape.h() + b.shape.getFlangeThickness() +
flangePlate.thickness) / 2.0
halfD = flangePlate.length / 2.0
print('half H:', halfH * 1e3, 'mm')
print('half D:', halfD * 1e3, 'mm')
# Top plate
topPlateCenter = b.memberOrigin + halfH * baseVectors[
1] + halfD * baseVectors[0]
topPlateRefSys = geom.Ref3d3d(topPlateCenter, baseVectors[0],
baseVectors[2])
topPlateBlocks = flangePlate.getBlocks(
refSys=topPlateRefSys, blockProperties=plateProperties)
retval.extend(topPlateBlocks)
# Holes in top flange
print('has holes: ', topPlateBlocks.hasHoles())
holesList = topPlateBlocks.getHoles()
for holes in holesList:
for key in holes.points:
p = holes.points[key]
objType = p.getAttribute('objType')
if (objType == 'hole_center'):
pos = geom.Pos3d(p.getX(), p.getY(), p.getZ())
diameter = p.getAttribute('diameter')
nearestFace = beamBlocks.getNearest(pos)
posInFlange = nearestFace.getGeomObject(
beamBlocks.points).getPlane().getPos3dProjection(
pos)
dist = posInFlange.dist(pos)
print(pos, objType, diameter, nearestFace.id, dist)
XXX
quit()
# Bottom plate
bottomPlateCenter = b.memberOrigin - halfH * baseVectors[
1] + halfD * baseVectors[0]
bottomPlateRefSys = geom.Ref3d3d(bottomPlateCenter, baseVectors[0],
baseVectors[2])
bottomPlateBlocks = flangePlate.getBlocks(
refSys=bottomPlateRefSys, blockProperties=plateProperties)
retval.extend(bottomPlateBlocks)
return retval
def getBlocks(self, blockProperties):
''' Return the block decomposition of the base plates.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval = bte.BlockData()
for key in self.basePlates:
basePlate = self.basePlates[key]
retval.extend(basePlate.getBlocks(blockProperties))
return retval
def getAnchorBlock(self, refSys= geom.Ref3d3d(), blockProperties= None):
''' Return the hole contour and hole center as block topology entities.
:param refSys: coordinate reference system.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval= bte.BlockData()
blk= super(AnchorBase, self).getBoltBlock(refSys, blockProperties)
retval.extend(blk)
# Anchor point.
anchorPointProperties= self.getAnchorPointBlockProperties(blockProperties)
pA= blk.topPoint
center3d= geom.Pos3d(pA.coords[0], pA.coords[1], pA.coords[2])
pB= retval.appendPoint(-1, center3d.x, center3d.y, center3d.z-1*self.diameter, pointProperties= anchorPointProperties)
boltBlk= bte.BlockRecord(id= -1, typ= 'line', kPoints= [pA.id, pB])
id= retval.appendBlock(boltBlk)
return retval
def getBoltBlock(self, refSys= geom.Ref3d3d(), blockProperties= None):
''' Return the hole contour and hole center as block topology entities.
:param refSys: coordinate reference system.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
retval= bte.BlockData()
# Hole vertices.
holeProperties= bte.BlockProperties.copyFrom(blockProperties)
holeProperties.appendAttribute('objType', 'hole')
octagon= self.getHoleAsPolygon(refSys, nSides= 8).getVertexList()
blk= retval.blockFromPoints(octagon, holeProperties)
# Hole center.
centerProperties= self.getHoleCenterBlockProperties(blockProperties, blk.id)
center3d= refSys.getPosGlobal(self.pos3d)
pA= retval.appendPoint(-1, center3d.x, center3d.y, center3d.z, pointProperties= centerProperties)
retval.topPoint= retval.points[pA]
return retval
def createHolesOnMemberBlocks(templateHoles, memberBlocks, boltProperties,
materialsModuleName):
''' Projects the holes in the argument onto the surfaces
of the member blocks to create the holes in those
surfaces.
:param templateHoles: holes that will be projected on the
member surfaces, typically from a bolted
plate that will be attached to the
member.
:param memberBlocks: surfaces corresponding to the member plates:
flanges, web, etc. Those surfaces will receive
the new holes into them.
:param blockProperties: labels and attributes to assign to the newly created blocks.
:param materialsModuleName: name of the module that contains the material for the new bolts.
'''
retval = bte.BlockData()
# Import the materials module
matModule = importlib.import_module(materialsModuleName)
for holes in templateHoles:
for key in holes.points:
p = holes.points[key]
objType = p.getAttribute('objType')
if (objType == 'hole_center'):
pos = geom.Pos3d(p.getX(), p.getY(), p.getZ())
boltDiameter = p.getAttribute('diameter')
boltMaterialId = p.getAttribute('boltMaterial')
boltMaterial = getattr(matModule, boltMaterialId)
nearestFace = memberBlocks.getNearest(pos)
boltProperties.appendAttribute(
'ownerId', 'f' + str(nearestFace.id)) # Hole owner
nearestFacePlane = nearestFace.getGeomObject(
memberBlocks.points).getPlane()
posInFlange = nearestFacePlane.getPos3dProjection(pos)
refSys = geom.Ref3d3d(posInFlange, nearestFacePlane.getBase1(),
nearestFacePlane.getBase2())
bolt = matModule.BoltFastener(diameter=boltDiameter,
steelType=boltMaterial,
pos3d=geom.Pos3d(0, 0, 0))
boltBlk = bolt.getBoltBlock(refSys, boltProperties)
retval.extend(boltBlk)
return retval
def getBlocks(self,
refSys=geom.Ref3d3d(),
blockProperties=None,
loadTag=None,
loadDirI=None,
loadDirJ=None,
loadDirK=None):
''' Return the blocks that define the plate for the
diagonal argument.
:param blockProperties: labels and attributes to assign to the newly created blocks.
:param loadTag: tag of the applied loads in the internal forces file.
:param loadDirI: I vector of the original element. Vector that
points to the loaded side of the plate.
:param loadDirJ: J vector of the of the original element.
:param loadDirK: K vector of the of the original element.
'''
retval = bte.BlockData()
plateProperties = bte.BlockProperties.copyFrom(blockProperties)
plateProperties.appendAttribute('objType', 'bolted_plate')
if (loadTag):
plateProperties.appendAttribute('loadTag', loadTag)
plateProperties.appendAttribute(
'loadDirI', [loadDirI.x, loadDirI.y, loadDirI.z])
plateProperties.appendAttribute(
'loadDirJ', [loadDirJ.x, loadDirJ.y, loadDirJ.z])
plateProperties.appendAttribute(
'loadDirK', [loadDirK.x, loadDirK.y, loadDirK.z])
# Get the plate contour
contourVertices = self.getContour(refSys)
blk = retval.blockFromPoints(contourVertices,
plateProperties,
thickness=self.thickness,
matId=self.steelType.name)
# Get the hole blocks for the new plate
holeProperties = bte.BlockProperties.copyFrom(blockProperties)
holeProperties.appendAttribute('objType', 'hole')
holeProperties.appendAttribute('ownerId', 'f' + str(blk.id))
blk.holes = self.boltArray.getHoleBlocks(refSys, holeProperties)
retval.extend(blk.holes)
return retval
def getBlocks(self, verticalWeldLegSize, horizontalWeldLegSize,
boltedPlate, diagonal, origin, blockProperties):
''' Return the blocks corresponding to the gusset plate connection
and the single or double plates bolted to it.
:param verticalWeldLegSize: leg size for the vertical welds.
:param horizontalWeldLegSize: leg size for the horizontal welds.
:param boltedPlate: bolted plate that will be attached
to this one.
:param diagonal: element that provide the internal forces in the
bolted plate edge.
:param blockProperties: labels and attributes to assign to the newly created blocks.
:return: return the blocks corresponding to the connection.
'''
retval = bte.BlockData()
gussetPlateBlocks = self.getGussetBlocks(verticalWeldLegSize,
horizontalWeldLegSize,
blockProperties)
retval.extend(gussetPlateBlocks)
distBetweenPlates1, attachedPlateBlocks1 = self.getBoltedPlateBlocks(
boltedPlate, diagonal, origin, blockProperties,
side=1) # bolted plate at positive side.
retval.extend(attachedPlateBlocks1)
boltBlocks1 = bolted_plate.getBoltedPointBlocks(
gussetPlateBlocks, attachedPlateBlocks1,
abs(distBetweenPlates1)) # points linked by bolts.
retval.extend(boltBlocks1)
if (self.boltedPlateTemplate.doublePlate):
distBetweenPlates2, attachedPlateBlocks2 = self.getBoltedPlateBlocks(
boltedPlate, diagonal, origin, blockProperties,
side=-1) # bolted plate at negative side.
retval.extend(attachedPlateBlocks2)
boltBlocks2 = bolted_plate.getBoltedPointBlocks(
gussetPlateBlocks, attachedPlateBlocks2,
abs(distBetweenPlates2)) # points linked by bolts.
retval.extend(boltBlocks2)
return retval
def getHoleBlocks(self, refSys=geom.Ref3d3d(), blockProperties=None):
''' Return octagons inscribed in the holes.
:param refSys: coordinate reference system used to compute
the geometry of the holes.
:param blockProperties: labels and attributes of the holes.
'''
localPos = self.getLocalPositions()
holes = list()
for pLocal in localPos:
circle = geom.Circle2d(pLocal,
self.bolt.getNominalHoleDiameter() / 2.0)
octagon = circle.getInscribedPolygon(8, 0.0).getVertexList()
holes.append((pLocal, octagon))
retval = bte.BlockData()
# Base points (A)
for h in holes:
# Hole vertices.
holeVertices = list()
for v in h[1]:
p3d = geom.Pos3d(v.x, v.y, 0.0)
holeVertices.append(refSys.getPosGlobal(p3d))
blk = retval.blockFromPoints(holeVertices, blockProperties)
# Hole center.
centerProperties = bte.BlockProperties.copyFrom(blockProperties)
centerProperties.appendAttribute('objType', 'hole_center')
centerProperties.appendAttribute('ownerId', 'f' +
str(blk.id)) # Hole center owner.
centerProperties.appendAttribute('diameter', self.bolt.diameter)
centerProperties.appendAttribute('boltMaterial',
self.bolt.steelType.name)
center = h[0]
center3d = refSys.getPosGlobal(geom.Pos3d(center.x, center.y, 0.0))
retval.appendPoint(-1,
center3d.x,
center3d.y,
center3d.z,
pointProperties=centerProperties)
return retval
# 1 +--------------------+ 2
#
points= preprocessor.getMultiBlockTopology.getPoints
CooMax= 10.0
pt1= points.newPntFromPos3d(geom.Pos3d(0.0,0.0,0.0))
pt2= points.newPntFromPos3d(geom.Pos3d(CooMax,0.0,0.0))
pt3= points.newPntFromPos3d(geom.Pos3d(CooMax,CooMax,0.0))
pt4= points.newPntFromPos3d(geom.Pos3d(0.0,CooMax,0.0))
surfaces= preprocessor.getMultiBlockTopology.getSurfaces
s= surfaces.newQuadSurfacePts(pt1.tag,pt2.tag,pt3.tag,pt4.tag)
xcTotalSet= modelSpace.getTotalSet()
import ezdxf
bdTotal= bte.BlockData(verbosity= 0)
numEntitiesRead= bdTotal.readFromXCSet(xcTotalSet)
ok1= (abs(numEntitiesRead-8)==0)
# Avoid info messages
logging.getLogger(ezdxf.__name__).setLevel(logging.ERROR)
bdTotal.writeDxfFile(outputFileName)
import os
fileSize= os.path.getsize(outputFileName)
ok2= (fileSize>3000) and (fileSize<20000) # file exists and has a size that
# seems reasonable.
'''
print(numEntitiesRead)
print(fileSize)
'''
def getGussetBlocksForDiagonal(self, diagonal, blockProperties=None):
''' Return the blocks that define the gusset for the
diagonal argument.
:param diagonal: diagonal to get the gusset for.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
def getHalfChamferVector(diagonal):
''' Return a vector normal to the diagonal contained in
a vertical plane.'''
iVector = diagonal.iVector
# Horizontal vector perpendicular to the projection
# of iVector on the horizontal plane.
perpHoriz = geom.Vector3d(-iVector.y, iVector.x, 0.0)
return iVector.cross(perpHoriz).normalized()
retval = bte.BlockData()
origin = self.getOrigin()
baseVectors = diagonal.getDirection(origin)
extrusionLength = self.columnLengthFactor
p1 = origin + extrusionLength * baseVectors[0]
webPlane = self.getColumnWebMidPlane()
angleWithWeb = webPlane.getAngleWithVector3d(baseVectors[0])
dgSegment = geom.Segment3d(origin, p1)
gussetLength = self.gussetLengthFactor * self.boltedPlateTemplate.length
halfChamferVector = getHalfChamferVector(diagonal)
halfChamfer = self.boltedPlateTemplate.width / 2.0 * halfChamferVector
verticalWeldLegSize = 0.0 # leg size for the vertical welds.
horizontalWeldLegSize = math.floor(
self.getHorizontalWeldLegSize() *
1e3) / 1e3 # leg size for the horizontal welds.
if (abs(angleWithWeb) <
1e-3): # diagonal parallel to web => flange gusset.
verticalWeldLegSize = math.floor(
self.getFlangeLegSize() * 1e3) / 1e3
objType = 'flange_gusset'
gussetPlate = self.getFlangeGussetPlate(
baseVectors=baseVectors,
diagSegment=dgSegment,
gussetLength=gussetLength,
halfChamfer=halfChamfer,
slope=self.flangeGussetLegsSlope)
else: # diagonal normal to web => web gusset
verticalWeldLegSize = math.floor(self.getWebLegSize() * 1e3) / 1e3
objType = 'web_gusset'
gussetPlate = self.getWebGussetPlate(
baseVectors=baseVectors,
diagSegment=dgSegment,
gussetLength=gussetLength,
halfChamfer=halfChamfer,
bottomLegSlope=self.webGussetBottomLegSlope)
# Attached plate.
boltedPlate = self.getBoltedPlateTemplate()
gussetPlateProperties = bte.BlockProperties.copyFrom(blockProperties)
gussetPlateProperties.appendAttribute('objType', objType)
gussetPlateBlocks = gussetPlate.getBlocks(
verticalWeldLegSize,
horizontalWeldLegSize,
boltedPlate,
diagonal,
self.getOrigin(),
blockProperties=gussetPlateProperties)
retval.extend(gussetPlateBlocks)
return retval
v = np.cross(v1, v2)
print key, vertices, v
deckOrientationVectors = [np.array([0, 1, 0]), np.array([0, 0, 1])] #[X,Z]
deckFaces = checkFacesOrientation(deckFaces, deckOrientationVectors)
#printFaces(deckFaces)
dockOrientationVectors = [np.array([0, 1, 0]), np.array([-1, 0, 0])] #[X,Z]
dockFaces = checkFacesOrientation(dockFaces, dockOrientationVectors)
#printFaces(dockFaces)
parapetOrientationVectors = [np.array([0, 1, 0]), np.array([1, 0, 0])] #[X,Z]
parapetFaces = checkFacesOrientation(parapetFaces, parapetOrientationVectors)
#printFaces(parapetFaces)
#Block topology
blocks = bte.BlockData()
blocks.name = 'Gilamont_dock'
counter = 0
for p in kPoints:
blocks.appendPoint(id=counter, x=p[0], y=p[1], z=p[2])
counter += 1
faceGroups = [deckFaces, dockFaces, parapetFaces]
counter = 0
for key in lines:
line = lines[key]
block = bte.BlockRecord(counter, 'line', line, [key])
blocks.appendBlock(block)
counter += 1
