def CoordTrainLoads(fleetAngle, x, y, z):
# print '[x0,y0]=',[x,y]
rpto = RotatePoint(fleetAngle, [x, y, z])
x1 = rpto[0]
y1 = rpto[1]
x2 = x1 - 2 * math.cos(fleetAngle)
y2 = y1 + 2 * math.sin(fleetAngle)
x3 = x1 + 1.2 * math.sin(fleetAngle)
y3 = y1 + 1.2 * math.cos(fleetAngle)
x4 = x2 + 1.2 * math.sin(fleetAngle)
y4 = y2 + 1.2 * math.cos(fleetAngle)
# print '[x1,y1]=',[x1,y1]
# print '[x2,y2]=',[x2,y2]
# print math.sqrt((x2-x1)**2+(y2-y1)**2)
# print '[x3,y3]=',[x3,y3]
# print math.sqrt((x3-x1)**2+(y3-y1)**2)
# print '[x4,y4]=',[x4,y4]
# print math.sqrt((x4-x3)**2+(y4-y3)**2)
points = [
geom.Pos3d(x1, y1, z),
geom.Pos3d(x2, y2, z),
geom.Pos3d(x3, y3, z),
geom.Pos3d(x4, y4, z)
]
return sets.get_lstNod_from_lst3DPos(prep, points)
def applyOnNodesIn3Dpos(self, lst3DPos):
'''create springs in the nearest nodes to the coordinates in the
list of 3D positions given as parameter
'''
lstnod = sets_mng.get_lstNod_from_lst3DPos(
self.modelSpace.preprocessor, lst3DPos)
self.applyOnNodesLst(lstnod)
def putNodalLoads(vLoad):
nodLst = sets_mng.get_lstNod_from_lst3DPos(
preprocessor, lst3DPos=vLoad.getLoadPositions())
wheelsLoad = vLoad.loadModel.getLoads()
loadIndex = 0
for n in nodLst:
cLC.newNodalLoad(
n.tag, xc.Vector([0.0, 0.0, -wheelsLoad[loadIndex], 0, 0, 0]))
loadIndex += 1
def trafficPointLoads(centerTruck):
xc = centerTruck.x
yc = centerTruck.y
#p1=geom.Pos3d(xc-1,yc-0.6,0.0)
p2 = geom.Pos3d(xc + 1, yc - 0.6, 0.0)
#p3=geom.Pos3d(xc-1,yc+0.6,0.0)
p4 = geom.Pos3d(xc + 1, yc + 0.6, 0.0)
nodLst = sets_mng.get_lstNod_from_lst3DPos(preprocessor=prep,
lst3DPos=[p2, p4])
return nodLst
def trafficPointLoads(centerTruck):
xc = centerTruck.x
yc = centerTruck.y
p1 = geom.Pos3d(xc - 1, yc - 0.6, (yc - 0.6) * math.tan(alpha))
p2 = geom.Pos3d(xc + 1, yc - 0.6, (yc - 0.6) * math.tan(alpha))
p3 = geom.Pos3d(xc - 1, yc + 0.6, (yc + 0.6) * math.tan(alpha))
p4 = geom.Pos3d(xc + 1, yc + 0.6, (yc + 0.6) * math.tan(alpha))
nodLst = sets.get_lstNod_from_lst3DPos(preprocessor=prep,
lst3DPos=[p1, p2, p3, p4])
return nodLst
def CoordTrainLoads(xmin, ymin, z):
xmax = xmin + 1.20
ymax = ymin + 2.0
points = [
geom.Pos3d(xmin, ymin, z),
geom.Pos3d(xmin, ymax, z),
geom.Pos3d(xmax, ymin, z),
geom.Pos3d(xmax, ymax, z)
]
return sets.get_lstNod_from_lst3DPos(prep, points)
def trafficPointLoads(centerTruck):
xc=centerTruck.x
yc=centerTruck.y
zc=centerTruck.z
p1=geom.Pos3d(xc-lejesCarr,yc-lruedCarr/2.0,zc)
p2=geom.Pos3d(xc-lejesCarr,yc+lruedCarr/2.0,zc)
p3=geom.Pos3d(xc,yc-lruedCarr/2.0,zc)
p4=geom.Pos3d(xc,yc+lruedCarr/2.0,zc)
p5=geom.Pos3d(xc+lejesCarr,yc-lruedCarr/2.0,zc)
p6=geom.Pos3d(xc+lejesCarr,yc+lruedCarr/2.0,zc)
nodLst=sets.get_lstNod_from_lst3DPos(preprocessor=prep,lst3DPos=[p1,p2,p3,p4,p5,p6])
return nodLst
# SIA 269 load model 1 (mid span)
cLC = loadCaseManager.setCurrentLoadCase('liveLoad269_1')
# Traffic point loads.
lane1Axis = laneAxisLines[0]
lane1Sg = lane1Axis.getSegment(2)
lane1Center = lane1Sg.getCenterOfMass()
lane1CenterTrsvSlope = (transverseSlopes[1] + transverseSlopes[2]) * 0.5
lane1CenterLongSlope = lane1Sg.getVDir().normalizado()
loadPositions = [(-0.6, 1.0), (0.6, 1.0), (-0.6, -1.0), (0.6, -1.0)]
load3DPositions = list()
for p in loadPositions:
p3D = lane1Center + p[1] * lane1CenterTrsvSlope + p[
0] * lane1CenterLongSlope
load3DPositions.append(p3D)
lane1CenterNodLst = sets_mng.get_lstNod_from_lst3DPos(preprocessor,
lst3DPos=load3DPositions)
alphaQ1 = 0.7
Qk1 = alphaQ1 * 300e3 / 2.0 #N
Qk1LongBrake = 1.2 * Qk1 * lane1CenterLongSlope
Qk1TrsvBrake = -0.25 * 1.2 * Qk1 * lane1CenterTrsvSlope
Qk1TrsvCentrif = -0.033 * 1.2 * Qk1 * lane1CenterTrsvSlope
Qk1Brake = Qk1LongBrake + Qk1TrsvCentrif + Qk1TrsvBrake
Qk1Vector = geom.Vector3d(0.0, 0.0, -Qk1) + Qk1Brake
for n in lane1CenterNodLst:
cLC.newNodalLoad(
n.tag, xc.Vector([Qk1Vector.x, Qk1Vector.y, Qk1Vector.z, 0, 0, 0]))
lane2Axis = laneAxisLines[1]
lane2Sg = lane2Axis.getSegment(2)
lane2Center = lane2Sg.getCenterOfMass()
lane2CenterTrsvSlope = (transverseSlopes[1] + transverseSlopes[2]) * 0.5
lane2CenterLongSlope = lane2Sg.getVDir().normalizado()
lstMeshSets=[
beamXconcr_mesh, beamY_mesh,
columnZconcr_mesh, decklv1_mesh,
decklv2_mesh
],
vAccel=xc.Vector([0.0, 0.0, -grav]))
# Point load acting on one or several nodes
# name: name identifying the load
# lstNod: list of nodes on which the load is applied
# loadVector: xc.Vector with the six components of the load:
# xc.Vector([Fx,Fy,Fz,Mx,My,Mz]).
nodPLoad = sets.get_lstNod_from_lst3DPos(
preprocessor=prep,
lst3DPos=[
geom.Pos3d(0, yList[lastYpos] / 2.0, zList[lastZpos]),
geom.Pos3d(xList[lastXpos], yList[lastYpos] / 2.0, zList[lastZpos])
])
QpuntBeams = loads.NodalLoad(name='QpuntBeams',
lstNod=nodPLoad,
loadVector=xc.Vector([0, 0, -Qbeam, 0, 0, 0]))
# Uniform loads applied on shell elements
# name: name identifying the load
# xcSet: set that contains the surfaces
# loadVector: xc.Vector with the six components of the load:
# xc.Vector([Fx,Fy,Fz,Mx,My,Mz]).
# refSystem: reference system in which loadVector is defined:
# 'Local': element local coordinate system
# 'Global': global coordinate system (defaults to 'Global)
def applyOnNodesIn3Dpos(self,lst3DPos):
'''create springs in the nearest nodes to the coordinates in the
list of 3D positions given as parameter
'''
lstnod=sets_mng.get_lstNod_from_lst3DPos(self.modelSpace.preprocessor,lst3DPos)
self.applyOnNodesLst(lstnod)
loadVector=xc.Vector([0, 0, -alphQ1hw * Qk1wheel, 0, 0, 0]))
trafQLoadLane1SrSit12b = loads.NodalLoad(
name='trafQLoadLane1SrSit12b',
lstNod=CoordTrainLoads(fleetAngle, xList[lastXpos] / 2.0 + deltaX,
yList[YposLane1Sr[0]] + deltaY2,
zList[zPosDownDeck]),
loadVector=xc.Vector([0, 0, -alphQ1sr * Qk1wheel, 0, 0, 0]))
points = [
geom.Pos3d(xList[lastXpos] / 2.0,
(yList[YposLane1HwSit1[0]] + yList[YposLane1HwSit1[1]]) / 2.0 +
xList[lastXpos] / 2.0 / math.tan(fleetAngle), zList[lastZpos])
]
trafBrakingHwSit1 = loads.NodalLoad(
name='trafBrakingHwSit1',
lstNod=sets.get_lstNod_from_lst3DPos(prep, points),
loadVector=xc.Vector([
-brakingQhw * math.sin(fleetAngle), -brakingQhw * math.cos(fleetAngle),
0, 0, 0, 0
]))
points = [
geom.Pos3d(xList[lastXpos] / 2.0,
(yList[YposLane1HwSit2[0]] + yList[YposLane1HwSit2[1]]) / 2.0 +
xList[lastXpos] / 2.0 / math.tan(fleetAngle), zList[lastZpos])
]
trafBrakingHwSit2 = loads.NodalLoad(
name='trafBrakingHwSit2',
lstNod=sets.get_lstNod_from_lst3DPos(prep, points),
loadVector=xc.Vector([
-brakingQhw * math.sin(fleetAngle), -brakingQhw * math.cos(fleetAngle),
