def dead_LC(lcName,drivewaySet,qAsphalt,sidewalkSet=None,qSidewalk=None,barrierSet=None,qBarrier=None,deckEdgeSet=None,qDeckEdge=None):
'''Return the dead load case (asphalt, sidewalk, barriers, ...)
:param lcName: load case name
:param drivewaySet: driveway set of elements (where to apply asphalt load)
:param qAsphalt: uniform load due to asphalt weight
:param sidewalkSet:sidewalk set of elements (defaults to None)
:param qSidewalk: uniform surface dead load on sidewalks (defaults to None).
:param barrierSet: set of lines where to apply barrier linear loads (defaults to None).
:param qBarrier: uniform linear load due to barrier weight (defaults to None)
:param deckEdgeSet: set of lines in the edges of the deck (defaults to None).
:param qDeckEdge: uniform linear load to apply on the edges of the deck (defaults to None).
'''
preprocessor=drivewaySet.getPreprocessor
lc=lcases.LoadCase(preprocessor,lcName,"default","constant_ts")
lc.create()
# add surface loads
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'asph',xcSet=drivewaySet,loadVector=xc.Vector([0,0,-qAsphalt,0,0,0]),refSystem='Global')])
if sidewalkSet:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'sidew',xcSet=sidewalkSet,loadVector=xc.Vector([0,0,-qSidewalk,0,0,0]),refSystem='Global')])
#add linear loads
if barrierSet:
lc.addLstLoads([loads.UniformLoadOnLines(name= lcName+'barr', xcSet=barrierSet, loadVector=xc.Vector([0,0,-qBarrier,0,0,0]))])
if deckEdgeSet:
lc.addLstLoads([loads.UniformLoadOnLines(name= lcName+'deckEdg', xcSet=deckEdgeSet, loadVector=xc.Vector([0,0,-qDeckEdge,0,0,0]))])
return lc
def load_test_LC(lcName, deckSet, lstVehiclData, hDistrPL, slopeDistrPL=1.0):
'''Return load case that reproduces one configuration of a load
in a bridge.
:param lcName: load case name
:param deckSet: deck set of elements (used to distribute point loads)
:param lstVehiclData: list of data for each vehicle used in the load test.
for each vehicle, data are its type (instance of the class LoadModel)
and the coordinates (x,y) where to place the centroid of the vehicle
ex: lstVehiclData=[[truck38t_forward,(0,15)],
[truck26t_backward,(2,15), ...]
:param hDistrPL: height considered to distribute each point load with
slope slopeDistr
:param slopeDistrPL: slope (H/V) through hDistr to distribute the load of
a wheel (defaults to 1)
'''
preprocessor = deckSet.getPreprocessor
lc = lcases.LoadCase(preprocessor, lcName, "default", "constant_ts")
lc.create()
for vehicDat in lstVehiclData:
vehicType = vehicDat[0]
xCentr = vehicDat[1][0]
yCentr = vehicDat[1][1]
lc.addLstLoads([
lmb.VehicleDistrLoad(name=lcName + 'QpVL1',
xcSet=deckSet,
loadModel=vehicType,
xCentr=xCentr,
yCentr=yCentr,
hDistr=hDistrPL,
slopeDistr=slopeDistrPL)
])
return lc
def gradient_thermal_LC(lcName, lstGradThStrnData):
'''Return a thermal or rheological load case (shrinkage, creep,
thermal expansion, ...)
:param preprocessor: preprocessor
:param lcName: load case name
:param lstGradThStrnData: list of instances of gradThermalStrain class
that defines the data parameters (set, element thickness,
DOF, alpha, temperatures on top and bottom faces)
'''
preprocessor = lstGradThStrnData[0].elemSet.getPreprocessor
lc = lcases.LoadCase(preprocessor, lcName, "default", "constant_ts")
lc.create()
for sd in lstGradThStrnData:
lc.addLstLoads([
loads.StrainGradientThermalLoadOnShells(name=lcName +
sd.elemSet.name,
elemSet=sd.elemSet,
elThick=sd.elThick,
DOF=sd.DOF,
alpha=sd.alpha,
Ttop=sd.Ttop,
Tbottom=sd.Tbottom)
])
return lc
def IAP_traffic_LC(lcName,deckSet,virtLane1Set,xyCentPL1,hDistrPL,slopeDistrPL=1.0,vQbraking=None,virtLane2Set=None,xyCentPL2=None,virtLane3Set=None,xyCentPL3=None,restDrivewaySet=None,sidewalkSet=None):
'''Return a traffic load case according to IAP.
:param lcName: load case name
:param deckSet: deck set of elements (used to distribute point loads)
:param virtLane1Set: virtual lane 1 set of elements
:param xyCentPL1: [xCent,yCent] global coord. X,Y where to place the centroid of the
vehicle on virtual lane 1
:param hDistrPL: height considered to distribute each point load with
slope slopeDistr
:param slopeDistrPL: slope (H/V) through hDistr to distribute the load of
a wheel (defaults to 1)
:param vQbraking: [qfrenX,qfrenY] x, y components of the uniform load due to braking
on virtual lane 1 (defaults to None)
:param virtLane2Set: virtual lane 2 set of elements
:param xyCentPL2: [xCent,yCent] global coord. X,Y where to place the centroid of the
vehicle on virtual lane 2
:param virtLane3Set: virtual lane 3 set of elements (defaults to None, not considered)
:param xyCentPL3: [xCent,yCent] global coord. X,Y where to place the centroid of the
vehicle on virtual lane 3 (defaults to None)
:param restDrivewaySet: rest of driveway set of elements (defaults to None, not considered)
:param sidewalkSet: sidewalk set of elements (defaults to None, not considered)
'''
preprocessor=deckSet.getPreprocessor
if vQbraking:
qunifVL1,qunifVL2,qunifVL3,qunifRest,qunifSidewalk=[0.4*9e3]+4*[0.4*2.5e3] #uniform load on virtual lanes, rest of driveway and sidewalks when braking forceis considered
QpointVL1,QpointVL2,QpointVL3=[IAP_carril_virt1_fren,IAP_carril_virt2_fren,IAP_carril_virt3_fren]
else:
qunifVL1,qunifVL2,qunifVL3,qunifRest,qunifSidewalk=[9e3]+4*[2.5e3]
QpointVL1,QpointVL2,QpointVL3=[IAP_carril_virt1,IAP_carril_virt2,IAP_carril_virt3]
lc=lcases.LoadCase(preprocessor,lcName,"default","constant_ts")
lc.create()
# add uniform loads
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'quVL1',xcSet=virtLane1Set,loadVector=xc.Vector([0,0,-qunifVL1,0,0,0]),refSystem='Global')])
if virtLane2Set:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'quVL2',xcSet=virtLane2Set,loadVector=xc.Vector([0,0,-qunifVL2,0,0,0]),refSystem='Global')])
if virtLane3Set:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'quVL3',xcSet=virtLane3Set,loadVector=xc.Vector([0,0,-qunifVL3,0,0,0]),refSystem='Global')])
if restDrivewaySet:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'quVL3',xcSet=restDrivewaySet,loadVector=xc.Vector([0,0,-qunifRest,0,0,0]),refSystem='Global')])
if sidewalkSet:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'quVL3',xcSet=sidewalkSet,loadVector=xc.Vector([0,0,-qunifSidewalk,0,0,0]),refSystem='Global')])
#add point loads
lc.addLstLoads([lmb.VehicleDistrLoad(name=lcName+'QpVL1',xcSet=deckSet,loadModel=QpointVL1, xCentr=xyCentPL1[0],yCentr=xyCentPL1[1],hDistr=hDistrPL,slopeDistr=slopeDistrPL)])
if virtLane2Set:
lc.addLstLoads([lmb.VehicleDistrLoad(name=lcName+'QpVL2',xcSet=deckSet,loadModel=QpointVL2, xCentr=xyCentPL2[0],yCentr=xyCentPL2[1],hDistr=hDistrPL,slopeDistr=slopeDistrPL)])
if virtLane3Set:
lc.addLstLoads([lmb.VehicleDistrLoad(name=lcName+'QpVL3',xcSet=deckSet,loadModel=QpointVL3, xCentr=xyCentPL3[0],yCentr=xyCentPL3[1],hDistr=hDistrPL,slopeDistr=slopeDistrPL)])
#add braking load
if vQbraking:
lc.addLstLoads([loads.UniformLoadOnSurfaces(name= lcName+'qfren',xcSet=virtLane1Set,loadVector=xc.Vector([vQbraking[0],vQbraking[1],0,0,0,0]),refSystem='Global')])
return lc
def thermal_rheological_LC(lcName,lstUnifThStrnData):
'''Return a thermal or rheological load case (shrinkage, creep,
thermal expansion, ...)
:param lcName: load case name
:param lstUnifThStrnData: list of instances of 'unifStrain' or
'unifThermalStrain' classes that defines the data
parameters (set, DOF, strain, temperature, ...)
'''
preprocessor=lstUnifThStrnData[0].elemSet.getPreprocessor
lc=lcases.LoadCase(preprocessor,lcName,"default","constant_ts")
lc.create()
for sd in lstUnifThStrnData:
lc.addLstLoads([loads.StrainLoadOnShells(name=lcName+sd.elemSet.name,xcSet=sd.elemSet,DOFstrain=sd.DOF,strain=sd.strain)])
return lc
def wind_LC(lcName,
deckLineSet,
vectWindDeck,
windwardPileSet,
vectWindwardPile,
leewardPileSet=None,
vectLeewardPile=None):
'''Return the dead load case (asphalt, sidewalk, barriers, ...)
:param lcName: load case name
:param deckLineSet: set of lines to apply wind on deck.
:param vectWindDeck: components [vx,vy] of the uniform linear load due to wind on deck.
:param windwardPileSet:set of lines to apply on piles windward.
:param vectWindwardPile: components [vx,vy] of the uniform linear load due to wind on piles (windward side).
:param leewardPileSet:set of lines to apply wind on pilesleeward (defaults to None).
:param vectLeewardPile: components [vx,vy] of the uniform linear load due to wind on piles (leeward side) (defaults to None).
'''
preprocessor = deckLineSet.getPreprocessor
lc = lcases.LoadCase(preprocessor, lcName, "default", "constant_ts")
lc.create()
#add linear loads
lc.addLstLoads([
loads.UniformLoadOnLines(name=lcName + 'deck',
xcSet=deckLineSet,
loadVector=xc.Vector([
vectWindDeck[0], vectWindDeck[1], 0, 0, 0,
0
]))
])
lc.addLstLoads([
loads.UniformLoadOnLines(name=lcName + 'pilewindward',
xcSet=windwardPileSet,
loadVector=xc.Vector([
vectWindwardPile[0], vectWindwardPile[1],
0, 0, 0, 0
]))
])
if leewardPileSet:
lc.addLstLoads([
loads.UniformLoadOnLines(name=lcName + 'pileleeward',
xcSet=leewardPileSet,
loadVector=xc.Vector([
vectLeewardPile[0],
vectLeewardPile[1], 0, 0, 0, 0
]))
])
return lc
#Thermal contraction
## tangential
thermContrTang = loads.StrainLoadOnShells(name='thermContrTang',
xcSet=tankwall,
DOFstrain=0,
strain=tempFall * steel.alpha)
## vertical
thermContrVert = loads.StrainLoadOnShells(name='thermContrVert',
xcSet=tankwall,
DOFstrain=1,
strain=tempFall * steel.alpha)
# ***LOAD CASES***
GselfWeight = lcases.LoadCase(preprocessor=prep,
name="GselfWeight",
loadPType="default",
timeSType="constant_ts")
GselfWeight.create()
GselfWeight.addLstLoads([selfWeight])
'''
modelSpace.addLoadCaseToDomain("GselfWeight")
out.displayLoadVectors()
modelSpace.removeLoadCaseFromDomain("GselfWeight")
'''
wind = lcases.LoadCase(preprocessor=prep,
name="wind",
loadPType="default",
timeSType="constant_ts")
wind.create()
for e in tankwall.elements:
# ***BOUNDARY CONDITIONS***
n1=pnt1.getNode()
modelSpace.fixNode('FFF_FFF',n1.tag)
n2=pnt2.getNode()
modelSpace.fixNode('FFF_FFF',n2.tag)
# ***ACTIONS***
from actions import loads
#Uniform load on beams
totalLoadBeam=loads.UniformLoadOnBeams(name='totalLoadBeam', xcSet=beamSet, loadVector=fUnif,refSystem='Global')
halfLoadBeam=loads.UniformLoadOnBeams(name='halfLoadBeam', xcSet=beamSet, loadVector=fUnif*0.5,refSystem='Global')
# ***LOAD CASES***
from actions import load_cases as lcases
lcase01=lcases.LoadCase(preprocessor=prep,name="lcase01",loadPType="default",timeSType="constant_ts")
lcase01.create()
lcase01.addLstLoads([totalLoadBeam])
lcase02=lcases.LoadCase(preprocessor=prep,name="lcase02",loadPType="default",timeSType="constant_ts")
lcase02.create()
lcase02.addLstLoads([halfLoadBeam])
from postprocess.xcVtk.FE_model import quick_graphics as QGrph
# ***LIMIT STATE COMBINATIONS***
from actions import combinations as cc
combContainer= cc.CombContainer() #Container of load combinations
#Frequent combinations.
# syntax: UniformLoadOnBeams(name, xcSet, loadVector,refSystem)
# name: name identifying the load
# xcSet: set that contains the lines
# 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)
unifLoadBeamsY=loads.UniformLoadOnBeams(name='unifLoadBeamsY', xcSet=beamY, loadVector=xc.Vector([0,0,-qunifBeam,0,0,0]),refSystem='Global')
# ***LOAD CASES***
qunifBeams=lcases.LoadCase(preprocessor=prep,name="qunifBeams",loadPType="default",timeSType="constant_ts")
qunifBeams.create()
qunifBeams.addLstLoads([unifLoadBeamsY])
# ***LIMIT STATE COMBINATIONS***
combContainer= cc.CombContainer() #Container of load combinations
# COMBINATIONS OF ACTIONS FOR SERVICEABILITY LIMIT STATES
# name: name to identify the combination
# rare: combination for a rare design situation
# freq: combination for a frequent design situation
# qp: combination for a quasi-permanent design situation
# earthquake: combination for a seismic design situation
#Characteristic combinations.
combContainer.SLS.rare.add('ELSR01', '1.0*qunifBeams')
if(pos.z>1.5-0.4):
impactOnHead.elements.append(e)
else:
if((pos.z<(0.75+0.2)) and (pos.z>(0.75-0.2))):
impactOnBody.elements.append(e)
impactOnHead.fillDownwards()
impactOnBody.fillDownwards()
# ***ACTIONS***
impactUniformLoad= 300e3/1.5/0.4
# Impact on parapet head:
impactOnHeadLoad= loads.UniformLoadOnSurfaces(name= 'impactOnHeadLoad',xcSet=impactOnHead,loadVector=xc.Vector([impactUniformLoad,0,0]),refSystem='Global')
impactOnBodyLoad= loads.UniformLoadOnSurfaces(name= 'impactOnBodyLoad',xcSet=impactOnBody,loadVector=xc.Vector([impactUniformLoad,0,0]),refSystem='Global')
# ***LOAD CASES***
A1=lcases.LoadCase(preprocessor=prep,name="A1",loadPType="default",timeSType="constant_ts")
A1.create()
A1.addLstLoads([impactOnHeadLoad])
A2=lcases.LoadCase(preprocessor=prep,name="A2",loadPType="default",timeSType="constant_ts")
A2.create()
A2.addLstLoads([impactOnBodyLoad])
# ***LOAD COMBINATIONS***
combContainer= cc.CombContainer() #Container of load combinations
# COMBINATIONS OF ACTIONS FOR ULTIMATE LIMIT STATES
combContainer.ULS.perm.add('ULSA1', '1.00*A1')
combContainer.ULS.perm.add('ULSA2', '1.00*A2')
# a wheel
from actions.roadway_trafic import IAP_load_models as slm
from actions.roadway_trafic import load_model_base as lmb
vehicleDeck1 = lmb.VehicleDistrLoad(name='vehicleDeck1',
xcSet=decklv1,
loadModel=slm.IAP_carril_virt3_fren,
xCentr=LbeamX / 2,
yCentr=LbeamY / 2.,
hDistr=0.25,
slopeDistr=1.0)
# ***LOAD CASES***
GselfWeight = lcases.LoadCase(preprocessor=prep,
name="GselfWeight",
loadPType="default",
timeSType="constant_ts")
GselfWeight.create()
GselfWeight.addLstLoads([selfWeight])
'''
modelSpace.addLoadCaseToDomain("GselfWeight")
out.displayLoadVectors()
modelSpace.removeLoadCaseFromDomain("GselfWeight")
'''
Qdecks = lcases.LoadCase(preprocessor=prep, name="Qdecks")
Qdecks.create()
Qdecks.addLstLoads([unifLoadDeck1, unifLoadDeck2])
QearthPressWall = lcases.LoadCase(preprocessor=prep,
name="QearthPressWall",
xcSet=leftWall,
soilData=soil01,
vDir=xc.Vector([1, 0, 0]))
earthPressLoadrightWall = loads.EarthPressLoad(name='earthPressLoadrightWall',
xcSet=rightWall,
soilData=soil01,
vDir=xc.Vector([-1, 0, 0]))
earthPressLoadmidWall = loads.EarthPressLoad(
name='earthPressLoadmidWall',
xcSet=midWall,
soilData=soil01,
vDir=xc.Vector([math.cos(fleetAngle), -math.sin(fleetAngle), 0]))
# ***LOAD CASES***
GselfWeight = lcases.LoadCase(preprocessor=prep,
name='GselfWeight',
loadPType="default",
timeSType="constant_ts")
GselfWeight.create()
GselfWeight.addLstLoads([selfWeight])
GdeadLoad = lcases.LoadCase(preprocessor=prep,
name='GdeadLoad',
loadPType="default",
timeSType="constant_ts")
GdeadLoad.create()
GdeadLoad.addLstLoads([deadLoadAsphalt, deadLoadSubbSr, deadLoadGuardrail])
GearthPress = lcases.LoadCase(preprocessor=prep,
name='GearthPress',
loadPType="default",
timeSType="constant_ts")
GearthPress.create()
GearthPress.addLstLoads(
Q3_4_loads = [Q3_4_n1, Q3_4_n2, Q3_4_n3, Q3_4_n4]
#G3
G3_n1 = loads.NodalLoad('G3_n1', [nodesAp[0]],
xc.Vector(React['G3']['Restr1_n1']) * (-1))
G3_n2 = loads.NodalLoad('G3_n2', [nodesAp[1]],
xc.Vector(React['G3']['Restr1_n2']) * (-1))
G3_n3 = loads.NodalLoad('G3_n3', [nodesAp[2]],
xc.Vector(React['G3']['Restr1_n3']) * (-1))
G3_n4 = loads.NodalLoad('G3_n4', [nodesAp[3]],
xc.Vector(React['G3']['Restr1_n4']) * (-1))
G3_loads = [G3_n1, G3_n2, G3_n3, G3_n4]
# ***LOAD CASES***
G1 = lcases.LoadCase(preprocessor=prep,
name="G1",
loadPType="default",
timeSType="constant_ts")
G1.create()
G1.addLstLoads([selfWeight] + G1_loads)
G2 = lcases.LoadCase(preprocessor=prep,
name="G2",
loadPType="default",
timeSType="constant_ts")
G2.create()
G2.addLstLoads(G2_loads)
G3 = lcases.LoadCase(preprocessor=prep,
name="G3",
loadPType="default",
timeSType="constant_ts")
e.sectionArea=diag_mat.A()
#Boundary conditions
nodBase=sets.get_set_nodes_plane_XY(setName='nodBase', setBusq=columns, zCoord=zGround, tol=0.001)
for n in nodBase.nodes:
modelSpace.fixNode('000_000',n.tag)
# Wind action
windParams=bw.windParams(v,Kd,Kzt,I,alpha,zg)
wind_columns=loads.WindLoadOnBeams('wind_columns',columns,windParams,Cp,xc.Vector([0,1,0]),column_mat.h())
wind_beams=loads.WindLoadOnBeams('wind_beams',beams,windParams,Cp,xc.Vector([0,1,0]))
wind_diagonals=loads.WindLoadOnTrusses('wind_diagonals',diagonals,windParams,Cp,xc.Vector([0,1,0]),diag_mat.h())
# ***LOAD CASES***
LC1=lcases.LoadCase(preprocessor=prep,name="LC1",loadPType="default",timeSType="constant_ts")
LC1.create()
LC1.addLstLoads([wind_columns])
LC2=lcases.LoadCase(preprocessor=prep,name="LC2",loadPType="default",timeSType="constant_ts")
LC2.create()
LC2.addLstLoads([wind_beams])
LC3=lcases.LoadCase(preprocessor=prep,name="LC3",loadPType="default",timeSType="constant_ts")
LC3.create()
LC3.addLstLoads([wind_diagonals])
nReac1=gridGeom.getPntXYZ((0,0,0)).getNode()
nReac2=gridGeom.getPntXYZ((4,0,0)).getNode()
from solution import predefined_solutions
#Empuje del terreno en situación de construcción
soilConstr=ep.EarthPressureModel( zGround=zList[-1], zBottomSoils=[-10],KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10.0, gammaWater=grav)
ep_construct_set=gridGeom.getSetSurfMultiRegion(lstIJKRange=[gm.IJKRange((0,pyhast1,0),(lastXpos,pyhast1,lastZpos))],setName='ep_construct_set')
ep_construct= loads.EarthPressLoad(name= 'ep_construct', xcSet=ep_construct_set,soilData=soilConstr, vDir=xc.Vector([0,1,0]))
#cargas lineales vehículo en construcción
ql_construct_set=gridGeom.getSetSurfMultiRegion(lstIJKRange=[gm.IJKRange((pxcarr2+1,pyhast1,0),(pxcarr3,pyhast1,lastZpos))],setName='ql_construct_set')
ql=qlConstruct*1.3/(xList[pxcarr3]-xList[pxcarr2+1])
lineL1=ep.LineVerticalLoadOnBackfill(qLoad=ql, zLoad=zList[lastZpos],distWall=2.20)
lineL2=ep.LineVerticalLoadOnBackfill(qLoad=ql, zLoad=zList[lastZpos],distWall=0.10)
ql_construct=loads.EarthPressLoad(name= 'ql_construct', xcSet=ql_construct_set,soilData=None, vDir=xc.Vector([0,1,0]))
ql_construct.lineLoads=[lineL1,lineL2]
# ***LOAD CASES***
# G1: Peso propio
G1=lcases.LoadCase(preprocessor=prep,name="G1",loadPType="default",timeSType="constant_ts")
G1.create()
G1.addLstLoads([selfWeight])
# G2a: Carga muerta en servicio
G2a=lcases.LoadCase(preprocessor=prep,name="G2a",loadPType="default",timeSType="constant_ts")
G2a.create()
G2a.addLstLoads([cm_carr_trav_carr1,cm_carr_trav_carr2,
cm_carr_trav_carr3,cm_carr_trav_carr4,
cm_can_cabl,cm_can_cabl])
eval('1.3*cm_bal_tali') #add this weighted load to the curret load case
eval('1.3*cm_bal_i')
eval('1.3*cm_bal_d')
eval('1.3*cm_bal_tald')
centTr = geom.Pos2d(0.5, 1.5 * cantileverWidth)
Q1p_liveLoadA = loads.NodalLoad(name='Q1p_liveLoadA',
lstNod=trafficPointLoads(centTr),
loadVector=xc.Vector(
[0, 0, -Qpoint1_Trafmod1, 0, 0, 0]))
centTr = geom.Pos2d(2.4 - 0.2, 1.5 * cantileverWidth)
Q1p_accidental = loads.NodalLoad(name='Q1p_accidental',
lstNod=trafficPointLoads(centTr),
loadVector=xc.Vector(
[0, 0, -Qpoint1_Trafmod1, 0, 0, 0]))
# ***LOAD CASES***
GselfWeight = lcases.LoadCase(preprocessor=prep,
name="GselfWeight",
loadPType="default",
timeSType="constant_ts")
GselfWeight.create()
GselfWeight.addLstLoads([selfWeight])
GdeadLoad = lcases.LoadCase(preprocessor=prep,
name="GdeadLoad",
loadPType="default",
timeSType="constant_ts")
GdeadLoad.create()
GdeadLoad.addLstLoads([deadLoadRoadway, deadLoadSideway])
QliveLoadA = lcases.LoadCase(preprocessor=prep,
name="QliveLoadA",
loadPType="default",
timeSType="constant_ts")
#Empuje del terreno en situación de construcción
soilConstr=ep.EarthPressureModel(zGround=zList[-1], zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10.0, gammaWater=grav)
ep_construct_set=gridGeom.getSetSurfMultiRegion(lstIJKRange=[gm.IJKRange((0,pyhast1,0),(lastXpos,pyhast1,lastZpos))],setName='ep_construct_set')
ep_construct= loads.EarthPressLoad(name= 'ep_construct', xcSet=ep_construct_set,soilData=soilConstr, vDir=xc.Vector([0,1,0]))
#cargas lineales vehículo en construcción
ql_construct_set=gridGeom.getSetSurfMultiRegion(lstIJKRange=[gm.IJKRange((pxcarr2+1,pyhast1,0),(pxcarr3,pyhast1,lastZpos))],setName='ql_construct_set')
ql=qlConstruct*1.3/(xList[pxcarr3]-xList[pxcarr2+1])
lineL1=ep.LineVerticalLoadOnBackfill(qLoad=ql, zLoad=zList[lastZpos],distWall=2.20)
lineL2=ep.LineVerticalLoadOnBackfill(qLoad=ql, zLoad=zList[lastZpos],distWall=0.10)
ql_construct=loads.EarthPressLoad(name= 'ql_construct', xcSet=ql_construct_set,soilData=None, vDir=xc.Vector([0,1,0]))
ql_construct.lineLoads=[lineL1,lineL2]
# ***LOAD CASES***
# G1: Peso propio
G1=lcases.LoadCase(preprocessor=prep,name="G1",loadPType="default",timeSType="constant_ts")
G1.create()
G1.addLstLoads([selfWeight])
# G2a: Carga muerta en servicio
G2a=lcases.LoadCase(preprocessor=prep,name="G2a",loadPType="default",timeSType="constant_ts")
G2a.create()
G2a.addLstLoads([cm_rell_tali1,cm_rell_tali2,cm_rell_tali3,cm_rell_i,
cm_rell_d,cm_rell_tald1,cm_rell_tald2,cm_rell_tald3,
cm_carr_trav_carr1,cm_carr_trav_carr2,
cm_carr_trav_carr3,cm_carr_trav_carr4,
cm_can_cabl_i,cm_can_cabl_d])
eval('1.3*cm_bal_tali') #add this weighted load to the curret load case
eval('1.3*cm_bal_i')
eval('1.3*cm_bal_d')
eval('1.3*cm_bal_tald')
zWater=-10.0,
gammaWater=grav)
ep_muri_z1 = loads.EarthPressLoad(name='ep_muri_z1',
xcSet=muri_z1_set,
soilData=soilZ1,
vDir=xc.Vector([0, 1, 0]))
ep_murd_z1 = loads.EarthPressLoad(name='ep_murd_z1',
xcSet=murd_z1_set,
soilData=soilZ1,
vDir=xc.Vector([0, -1, 0]))
# ***LOAD CASES***
# G1: Peso propio
G1 = lcases.LoadCase(preprocessor=prep,
name="G1",
loadPType="default",
timeSType="constant_ts")
G1.create()
G1.addLstLoads([selfWeight])
#G2: carga muerta sobre dintel
G2 = lcases.LoadCase(preprocessor=prep,
name="G2",
loadPType="default",
timeSType="constant_ts")
G2.create()
G2.addLstLoads([cp_dintel])
# G3: Empuje del terreno
G3 = lcases.LoadCase(preprocessor=prep,
name="G3",
# Boundary condition
nodBase = sets.get_set_nodes_plane_XY(setName='nodBase',
setBusq=tank,
zCoord=zBase,
tol=0.001)
for n in nodBase.nodes:
modelSpace.fixNode('000_FFF', n.tag)
# Loading
windParams = bw.windParams(v, Kd, Kzt, I, alpha, zg)
tankWind = bw.cylindrWind(2 * R, height, windParams, windComp, zGround, xCent,
yCent)
WX = lcases.LoadCase(preprocessor=prep,
name="WX",
loadPType="default",
timeSType="constant_ts")
WX.create()
for e in tank.elements:
vCoo = e.getCooCentroid(0)
pres = Gf * tankWind.getWindPress(vCoo[0], vCoo[1], vCoo[2])
loadVector = xc.Vector([0, 0, -pres])
e.vector3dUniformLoadLocal(loadVector)
modelSpace.removeAllLoadPatternsFromDomain()
modelSpace.addLoadCaseToDomain('WX')
modelSpace.analyze(calculateNodalReactions=True)
def getResultReactForces(dof, nodSet):
'''dof=0 for Rx, dof=1 for Ry, dof=2 for Rz
roof_mesh=fem.SurfSetToMesh(surfSet=roof,matSect=roof_mat,elemSize=eSize,elemType='ShellMITC4')
roof_mesh.generateMesh(prep)
# ***BOUNDARY CONDITIONS***
#fixed DOF (ux:'0FF_FFF', uy:'F0F_FFF', uz:'FF0_FFF',
# rx:'FFF_0FF', ry:'FFF_F0F', rz:'FFF_FF0')
p1=gridGeom.getPntGrid(indPnt=(0,0,lastZpos))
modelSpace.fixNode('000_FFF',p1.getNode().tag)
p2=gridGeom.getPntGrid(indPnt=(lastXpos,0,lastZpos))
modelSpace.fixNode('000_FFF',p2.getNode().tag)
p3=gridGeom.getPntGrid(indPnt=(0,lastYpos,lastZpos))
modelSpace.fixNode('000_FFF',p3.getNode().tag)
p4=gridGeom.getPntGrid(indPnt=(lastXpos,lastYpos,lastZpos))
modelSpace.fixNode('000_FFF',p4.getNode().tag)
# ***ACTIONS***
#Inertial load (density*acceleration) applied to the elements in a set
grav=9.81 #Gravity acceleration (m/s2)
#selfWeight=loads.InertialLoad(name='selfWeight', lstMeshSets=[beamXconcr_mesh,beamY_mesh,columnZconcr_mesh,deck_mesh,wall_mesh,foot_mesh], vAccel=xc.Vector( [0.0,0.0,-grav]))
selfWeight=loads.InertialLoad(name='selfWeight', lstMeshSets=[roof_mesh], vAccel=xc.Vector( [0.0,0.0,-grav]))
# ***LOAD CASES***
GselfWeight=lcases.LoadCase(preprocessor=prep,name="GselfWeight",loadPType="default",timeSType="constant_ts")
GselfWeight.create()
GselfWeight.addLstLoads([selfWeight])
overallSet=roof
