Beispiel #1
0
#                 gammaSoils: list of weight density for each soil (from top to
#                   bottom)
#                 zWater: global Z coordinate of groundwater level
#                   (if zGroundwater<minimum z of model => there is no groundwater)
#                 gammaWater: weight density of water
#                 qUnif: uniform load over the backfill surface (defaults to 0)
#     vDir: unit xc vector defining pressures direction

soil01 = ep.EarthPressureModel(zGround=zList[lastZpos] - 3,
                               zBottomSoils=[-10],
                               KSoils=[KearthPress],
                               gammaSoils=[densSoil * grav],
                               zWater=0,
                               gammaWater=densWater * grav)
earthPressLoadWall = loads.EarthPressLoad(name='earthPressLoadWall',
                                          xcSet=wall,
                                          soilData=soil01,
                                          vDir=xc.Vector([0, 1, 0]))

earthPressLoadColumn = loads.EarthPressLoad(name='earthPressLoadColumn',
                                            xcSet=columnZconcr,
                                            soilData=soil01,
                                            vDir=xc.Vector([0, 1, 0]))

soil02 = ep.EarthPressureModel(zGround=zList[lastZpos],
                               zBottomSoils=[-10],
                               KSoils=[0.001],
                               gammaSoils=[densSoil * grav],
                               zWater=0.05,
                               gammaWater=densWater * grav)
stripL01 = ep.StripLoadOnBackfill(qLoad=2e5,
                                  zLoad=zList[lastZpos],
Beispiel #2
0
    gm.IJKRange((0, lastYpos, 0), (lastXpos, lastYpos, lastZpos))
],
                                             setName='murd_z1_set')

# empuje del terreno
zGroundZ1 = zList[lastZpos] + deckTh / 2.0

soilZ1 = ep.EarthPressureModel(zGround=zGroundZ1,
                               zBottomSoils=[-10],
                               KSoils=[K0],
                               gammaSoils=[densrell * grav],
                               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
Beispiel #3
0
zGroundZ2=zList[lastZpos]+deckTh/2.0+(Hrelli+Hrelld)/2.0
zGroundZ3=zList[lastZpos]+deckTh/2.0+Hrelli+Hbali
zGroundZ4=zList[lastZpos]+deckTh/2.0+Hrelld+Hbald
zGroundZ4_desbalastado=zList[lastZpos]+deckTh/2.0+Hrelld

soilZ1_1=ep.EarthPressureModel( zGround=zGroundZ1_1,zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10.0, gammaWater=grav)
soilZ1_2=ep.EarthPressureModel(zGround=zGroundZ1_2,zBottomSoils=[-10], KSoils=[K0], gammaSoils=[densrell*grav], zWater=-10.0, gammaWater=grav)
soilZ1_3=ep.EarthPressureModel(zGround=zGroundZ1_3, zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10.0, gammaWater=grav)

soilZ2=ep.EarthPressureModel(zGround=zGroundZ2, zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=0, gammaWater=0)
soilZ3=ep.EarthPressureModel(zGround=zGroundZ3, zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10, gammaWater=grav)
soilZ4=ep.EarthPressureModel(zGround=zGroundZ4, zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10, gammaWater=0)
soilZ4_desbal=ep.EarthPressureModel(zGround=zGroundZ4_desbalastado, zBottomSoils=[-10], KSoils=[K0],gammaSoils=[densrell*grav], zWater=-10, gammaWater=grav)

ep_muri_z1_1= loads.EarthPressLoad(name= 'ep_muri_z1_1', xcSet=muri_z1_1_set,soilData=soilZ1_1, vDir=xc.Vector([0,1,0]))
ep_muri_z1_2= loads.EarthPressLoad(name= 'ep_muri_z1_2', xcSet=muri_z1_2_set,soilData=soilZ1_2, vDir=xc.Vector([0,1,0]))
ep_muri_z1_3= loads.EarthPressLoad(name= 'ep_muri_z1_3', xcSet=muri_z1_3_set,soilData=soilZ1_3, vDir=xc.Vector([0,1,0]))

ep_muri_z2= loads.EarthPressLoad(name= 'ep_muri_z2', xcSet=muri_z2_set,soilData=soilZ2, vDir=xc.Vector([0,1,0]))
ep_muri_z3= loads.EarthPressLoad(name= 'ep_muri_z3', xcSet=muri_z3_set,soilData=soilZ3, vDir=xc.Vector([0,1,0]))
ep_muri_z4= loads.EarthPressLoad(name= 'ep_muri_z4', xcSet=muri_z4_set,soilData=soilZ4, vDir=xc.Vector([0,1,0]))
ep_muri_z4_desbal= loads.EarthPressLoad(name= 'ep_muri_z4', xcSet=muri_z4_set,soilData=soilZ4_desbal, vDir=xc.Vector([0,1,0]))


ep_murd_z1_1= loads.EarthPressLoad(name= 'ep_murd_z1_1', xcSet=murd_z1_1_set,soilData=soilZ1_1, vDir=xc.Vector([0,-1,0]))
ep_murd_z1_2= loads.EarthPressLoad(name= 'ep_murd_z1_2', xcSet=murd_z1_2_set,soilData=soilZ1_2, vDir=xc.Vector([0,-1,0]))
ep_murd_z1_3= loads.EarthPressLoad(name= 'ep_murd_z1_3', xcSet=murd_z1_3_set,soilData=soilZ1_3, vDir=xc.Vector([0,-1,0]))

ep_murd_z2= loads.EarthPressLoad(name= 'ep_murd_z2', xcSet=murd_z2_set,soilData=soilZ2, vDir=xc.Vector([0,-1,0]))
ep_murd_z3= loads.EarthPressLoad(name= 'ep_murd_z3', xcSet=murd_z3_set,soilData=soilZ3, vDir=xc.Vector([0,-1,0]))
Beispiel #4
0
#                   gammaSoil: weight density of soil
#                   zWater: global Z coordinate of groundwater level
#                           (if zGroundwater<minimum z of model => there is no groundwater)
#                   gammaWater: weight density of water
#     vDir: unit xc vector defining pressures direction

soil01 = ep.EarthPressureModel(zGround=zList[lastZpos] + asphaltTh,
                               zBottomSoils=[-10],
                               KSoils=[KearthPress],
                               gammaSoils=[densSoil * grav],
                               zWater=-10.0,
                               gammaWater=densWater * grav)
leftWall = leftDownWall + leftUpWall
rightWall = rightDownWall + rightUpWall
earthPressLoadleftWall = loads.EarthPressLoad(name='earthPressLoadleftWall',
                                              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",
                                       loadVector=xc.Vector([0, 0,
                                                             -qunifTerr]))

# empuje del terreno
soil = ep.EarthPressureModel(K=K0,
                             zGround=zGround,
                             gammaSoil=densrell * grav,
                             zWater=-10.0,
                             gammaWater=grav)
qunifTerr = ep.StripLoadOnBackfill(qLoad=qunifTerr,
                                   zLoad=zGround,
                                   distWall=0,
                                   stripWidth=10)

ep_aleti = loads.EarthPressLoad(name='ep_aleti',
                                xcSet=aleti,
                                soilData=soil,
                                vDir=xc.Vector([-1, 0, 0]))
ep_aletd = loads.EarthPressLoad(name='ep_aletd',
                                xcSet=aletd,
                                soilData=soil,
                                vDir=xc.Vector([1, 0, 0]))
ep_murestr = loads.EarthPressLoad(name='ep_murestr',
                                  xcSet=murestr,
                                  soilData=soil,
                                  vDir=xc.Vector([0, -1, 0]))

SCep_aleti = loads.EarthPressLoad(name='SCep_aleti',
                                  xcSet=aleti,
                                  soilData=None,
                                  vDir=xc.Vector([-1, 0, 0]))
SCep_aleti.stripLoads = [qunifTerr]
Beispiel #6
0
#                   zGround:global Z coordinate of ground level
#                   gammaSoil: weight density of soil
#                   zWater: global Z coordinate of groundwater level
#                           (if zGroundwater<minimum z of model => there is no groundwater)
#                   gammaWater: weight density of water
#     vDir: unit xc vector defining pressures direction

soil01 = ep.EarthPressureModel(zGround=zList[lastZpos],
                               zBottomSoils=[-10],
                               KSoils=[KearthPress],
                               gammaSoils=[densSoil * grav],
                               zWater=-10.0,
                               gammaWater=densWater * grav)

earthPressLoadleftWall = loads.EarthPressLoad(name='earthPressLoadleftWall',
                                              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]))

#    ***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',