__copyright__ = "Copyright 2015, LCPT and AOO"
__license__ = "GPL"
__version__ = "3.0"
__email__ = "*****@*****.**"
lado = 1.0
feProblem = xc.FEProblem()
preprocessor = feProblem.getPreprocessor
elast = typical_materials.defElasticMaterial(preprocessor, "elast", 1.0)
sectionGeometryTest = preprocessor.getMaterialHandler.newSectionGeometry(
"sectionGeometryTest")
regiones = sectionGeometryTest.getRegions
elast = regiones.newQuadRegion("elast")
elast.pMin = geom.Pos2d(0.0, 0.0)
elast.pMax = geom.Pos2d(lado, lado)
area = elast.getArea()
G = elast.getCdg()
Iy = elast.getIy()
Iz = elast.getIz()
Pyz = elast.getPyz()
areaTeor = lado * lado
yGTeor = lado / 2.0
zGTeor = lado / 2.0
iTeor = (lado)**4 / 12.0
ratio1 = ((area - areaTeor) / areaTeor)
ratio2 = ((G[0] - yGTeor) / yGTeor)
ratio3 = ((G[1] - zGTeor) / zGTeor)
# -*- coding: utf-8 -*-
from __future__ import print_function
import xc_base
import geom
import math
r1=geom.Line2d(geom.Pos2d(0.,0.),geom.Pos2d(10.,0.))
r2=geom.Line2d(geom.Pos2d(0.,-2.),geom.Pos2d(10.,-2.))
r3=geom.Line2d(geom.Pos2d(0.,2.),geom.Pos2d(10.,2.))
a=r2.getParamA()
b=r2.getParamB()
ratio1=math.fabs(a)
ratio2=math.fabs(b+2)
a=r3.getParamA()
b=r3.getParamB()
ratio3=math.fabs(a)
ratio4=math.fabs(b-2)
import os
fname= os.path.basename(__file__)
if ratio1<1e-15 and ratio2<1e-15 and ratio3<1e-15 and ratio4<1e-15 :
print("test ",fname,": ok.")
else:
print("test ",fname,": ERROR.")
print("numOfRebars= ",numOfRebars)
print("rebarsOffset= ",rebarsOffset)
'''
feProblem = xc.FEProblem()
preprocessor = feProblem.getPreprocessor
# Materials definition
concrMatTag25 = EHE_materials.HA25.defDiagK(preprocessor)
tagB400S = EHE_materials.B400S.defDiagK(preprocessor)
geomSecHA = preprocessor.getMaterialHandler.newSectionGeometry("geomSecHA")
regions = geomSecHA.getRegions
concrete = regions.newQuadRegion(EHE_materials.HA25.nmbDiagK)
concrete.nDivIJ = 10
concrete.nDivJK = 10
concrete.pMin = geom.Pos2d(-width / 2.0, -depth / 2.0)
concrete.pMax = geom.Pos2d(width / 2.0, depth / 2.0)
reinforcement = geomSecHA.getReinfLayers
reinforcementA = reinforcement.newStraightReinfLayer(
EHE_materials.B400S.nmbDiagK)
reinforcementA.numReinfBars = int(numOfRebars / 2)
reinforcementA.barArea = areaFi20
reinforcementA.p1 = geom.Pos2d(cover - width / 2.0, cover - depth / 2.0)
reinforcementA.p2 = geom.Pos2d(width / 2.0 - cover - rebarsSpacing,
cover - depth / 2.0)
reinforcementB = reinforcement.newStraightReinfLayer(
EHE_materials.B400S.nmbDiagK)
reinforcementB.numReinfBars = int(numOfRebars / 2)
reinforcementB.barArea = areaFi32
reinforcementB.p1 = geom.Pos2d(cover + rebarsSpacing - width / 2.0,
cover - depth / 2.0)
def getWFHeelEndPosition(self):
''' Returns the position of the heel end in the wireframe model.'''
stemBottomPos = self.getWFStemBottomPosition()
return geom.Pos2d(
stemBottomPos.x + self.stemTopWidth / 2.0 + self.bHeel,
stemBottomPos.y)
feProblem= xc.FEProblem()
preprocessor= feProblem.getPreprocessor
# Define materials
concr= EHE_materials.HA25
concr.alfacc=0.85 #f_maxd= 0.85*fcd concrete long term compressive strength factor (normally alfacc=1)
concrMatTag25= concr.defDiagD(preprocessor)
Ec= concr.getDiagD(preprocessor).getTangent
tagB500S= EHE_materials.B500S.defDiagD(preprocessor)
Es= EHE_materials.B500S.getDiagD(preprocessor).getTangent
geomSecHA= preprocessor.getMaterialHandler.newSectionGeometry("geomSecHA")
regions= geomSecHA.getRegions
concrete= regions.newQuadRegion(EHE_materials.HA25.nmbDiagD)
concrete.nDivIJ= 10
concrete.nDivJK= 10
concrete.pMin= geom.Pos2d(-depth/2.0,-width/2.0)
concrete.pMax= geom.Pos2d(depth/2.0,width/2.0)
reinforcement= geomSecHA.getReinfLayers
reinforcementInf= reinforcement.newStraightReinfLayer(EHE_materials.B500S.nmbDiagD)
reinforcementInf.numReinfBars= 2
reinforcementInf.barArea= areaFi16
reinforcementInf.p1= geom.Pos2d(cover-depth/2.0,width/2.0-cover) # bottom layer.
reinforcementInf.p2= geom.Pos2d(cover-depth/2.0,cover-width/2.0)
reinforcementSup= reinforcement.newStraightReinfLayer(EHE_materials.B500S.nmbDiagD)
reinforcementSup.numReinfBars= 2
reinforcementSup.barArea= areaFi16
reinforcementSup.p1= geom.Pos2d(depth/2.0-cover,width/2.0-cover) # top layer.
reinforcementSup.p2= geom.Pos2d(depth/2.0-cover,cover-width/2.0)
materialHandler= preprocessor.getMaterialHandler
secHA= materialHandler.newMaterial("fiber_section_3d","secHA")
# 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]).
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
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",
def getWFStemBottomPosition(self):
''' Returns the position of the stem bottom in the wireframe model.'''
return geom.Pos2d(self.stemTopPosition.x,
self.stemTopPosition.y - self.getWFStemHeigth())
def reCenter(self):
'''Put the centroid of the section in the
origin.'''
v = geom.Pos2d(0.0, 0.0) - self.plg.getCenterOfMass()
self.plg.move(v)
print "numBarras= ",numBarras
print "offsetBarras= ",offsetBarras
'''
feProblem = xc.FEProblem()
preprocessor = feProblem.getPreprocessor
# Materials definition
concrMatTag25 = EHE_materials.HA25.defDiagK(preprocessor)
tagB400S = EHE_materials.B400S.defDiagK(preprocessor)
geomSecHA = preprocessor.getMaterialHandler.newSectionGeometry("geomSecHA")
regions = geomSecHA.getRegions
concrete = regions.newQuadRegion(EHE_materials.HA25.nmbDiagK)
concrete.nDivIJ = 10
concrete.nDivJK = 10
concrete.pMin = geom.Pos2d(-width / 2.0, -depth / 2.0)
concrete.pMax = geom.Pos2d(width / 2.0, depth / 2.0)
reinforcement = geomSecHA.getReinfLayers
reinforcementInf = reinforcement.newStraightReinfLayer(
EHE_materials.B400S.nmbDiagK)
reinforcementInf.numReinfBars = numBarras
reinforcementInf.barArea = areaFi25
reinforcementInf.p1 = geom.Pos2d(offsetBarras - width / 2.0,
cover - depth / 2.0)
reinforcementInf.p2 = geom.Pos2d(width / 2.0 - offsetBarras,
cover - depth / 2.0)
reinforcementSup = reinforcement.newStraightReinfLayer(
EHE_materials.B400S.nmbDiagK)
reinforcementSup.numReinfBars = numBarras
reinforcementSup.barArea = areaFi10
reinforcementSup.p1 = geom.Pos2d(offsetBarras - width / 2.0,
respT = typical_materials.defElasticMaterial(
preprocessor, "respT", E) # Respuesta de la sección a torsión.
respVy = typical_materials.defElasticMaterial(
preprocessor, "respVy", E) # Respuesta de la sección a cortante según y.
respVz = typical_materials.defElasticMaterial(
preprocessor, "respVz", E) # Respuesta de la sección a cortante según y.
# Secciones
geomCuadFibrasTN = preprocessor.getMaterialLoader.newSectionGeometry(
"geomCuadFibrasTN")
y1 = widthOverZ / 2.0
z1 = depthOverY / 2.0
regiones = geomCuadFibrasTN.getRegions
elast = regiones.newQuadRegion("elast")
elast.nDivIJ = nDivIJ
elast.nDivJK = nDivJK
elast.pMin = geom.Pos2d(y0 - y1, z0 - z1)
elast.pMax = geom.Pos2d(y0 + y1, z0 + z1)
rectang = preprocessor.getMaterialLoader.newMaterial("fiber_section_3d",
"cuadFibrasTN")
fiberSectionRepr = rectang.getFiberSectionRepr()
fiberSectionRepr.setGeomNamed("geomCuadFibrasTN")
rectang.setupFibers()
fibras = rectang.getFibers()
# Respuestas a torsión y cortantes.
materiales = preprocessor.getMaterialLoader
agg = materiales.newMaterial("section_aggregator", "sa")
agg.setSection("cuadFibrasTN")
agg.setAdditions(["T", "Vy", "Vz"], ["respT", "respVy", "respVz"])
# Elements definition
# -*- coding: utf-8 -*-
from __future__ import print_function
import xc_base
import geom
import math
ptsPrb = geom.ListPos2d()
ptsPrb.appendPoint(geom.Pos2d(0, 0))
ptsPrb.appendPoint(geom.Pos2d(2, 0))
ptsPrb.appendPoint(geom.Pos2d(2, 2))
ptsPrb.appendPoint(geom.Pos2d(0, 2))
centerOfMassX = ptsPrb.getCenterOfMass().x
centerOfMassY = ptsPrb.getCenterOfMass().y
area = ptsPrb.getArea()
import os
fname = os.path.basename(__file__)
if math.fabs(centerOfMassX - 1.0) < 1e-15 and math.fabs(
centerOfMassY - 1.0) < 1e-15 and math.fabs(area) < 1e-15:
print("test ", fname, ": ok.")
else:
print("test ", fname, ": ERROR.")
# -*- coding: utf-8 -*-
from __future__ import print_function
import xc_base
import geom
import math
fromPoint = geom.Pos2d(0, 0)
toPoint = geom.Pos2d(10, 0)
s1 = geom.Segment2d(fromPoint, toPoint)
s2 = s1.offsetDouble(2)
s3 = s1.offsetDouble(-2)
p1 = s2.getCenterOfMass()
p2 = s3.getCenterOfMass()
ratio1 = math.fabs(p1.dist(p2) - 4)
import os
fname = os.path.basename(__file__)
if ratio1 < 1e-15:
print("test ", fname, ": ok.")
else:
print("test ", fname, ": ERROR.")
section = typical_materials.defElasticSection3d(preprocessor, "section", 1, 1,
1, 1, 1, 1)
lin = modelSpace.newLinearCrdTransf("lin", xc.Vector([0, -1, 0]))
# Elements definition
elements = preprocessor.getElementHandler
elements.defaultTransformation = lin.name
elements.defaultMaterial = section.name
elements.defaultTag = 1 #Tag for next element.
beam3d = elements.newElement("ElasticBeam3d", xc.ID([1, 2]))
centroidG = beam3d.getCoordTransf.getPointGlobalCoordFromBasic(0.5)
posCentroidG = geom.Pos3d(centroidG[0], centroidG[1], centroidG[2])
centroidL = beam3d.getCoordTransf.getPointLocalCoordFromGlobal(centroidG)
posCentroidL = geom.Pos2d(centroidL[0], centroidL[1])
centroidB = beam3d.getCoordTransf.getPointBasicCoordFromGlobal(centroidG)
centroidGTeor = geom.Pos3d(L * math.sqrt(3) / 6,
L * math.sqrt(3) / 6,
L * math.sqrt(3) / 6) # Centroid en globales.
ratio1 = posCentroidG.distPos3d(centroidGTeor)
centroidLTeor = geom.Pos2d(10, 0) # Local coordinates of the centroid.
ratio2 = posCentroidL.distPos2d(centroidLTeor)
centroidBTeor = 0.5 # Basic coordinates of the centroid.
ratio3 = abs(centroidB - centroidBTeor)
'''
print("global coordinates of the centroid: ",centroidG)
print("ratio1: ",ratio1)
print("local coordinates of the centroid: ",centroidL)
print("ratio2: ",ratio2)
# -*- coding: utf-8 -*-
from __future__ import print_function
import xc_base
import geom
pol1 = geom.Polygon2d()
pol1.appendVertex(geom.Pos2d(0, 0))
pol1.appendVertex(geom.Pos2d(1, 0))
pol1.appendVertex(geom.Pos2d(1, 1))
pol1.appendVertex(geom.Pos2d(0, 1))
perimPol1 = pol1.getPerimeter()
pol2 = pol1.offset(-0.25)
perimPol2 = pol2.getPerimeter()
ratio1 = (perimPol1 - 4) / 4.
ratio2 = (perimPol2 - 2) / 2.
import os
fname = os.path.basename(__file__)
if abs(ratio1) < 1e-10 and abs(ratio2) < 1e-10:
print("test ", fname, ": ok.")
else:
print("test ", fname, ": ERROR.")
__copyright__ = "Copyright 2015, LCPT and AOO"
__license__ = "GPL"
__version__ = "3.0"
__email__ = "*****@*****.**"
fy = 2600 # Yield stress of the material expressed in kp/cm2.
E = 2.1e6 # Young modulus of the material en kp/cm2.
xA = 1 / 3.0
yA = 3 / 4.0
feProblem = xc.FEProblem()
preprocessor = feProblem.getPreprocessor
epp = typical_materials.defElasticPPMaterial(preprocessor, "epp", E, fy, -fy)
sectionGeometryTest = preprocessor.getMaterialHandler.newSectionGeometry(
"sectionGeometryTest")
sectionGeometryTest.tagSpot = 1
spot1 = sectionGeometryTest.newSpot(geom.Pos2d(xA, yA))
x1 = spot1.pos.x
y1 = spot1.pos.y
spot2 = sectionGeometryTest.newSpot(geom.Pos2d(0, 0))
spot3 = sectionGeometryTest.newSpot(geom.Pos2d(10, 10))
dist = sectionGeometryTest.distSpots(1, 2)
linea1 = sectionGeometryTest.newSegment(2, 1)
lengthL1 = linea1.getLength()
linea2 = sectionGeometryTest.newSegment(1, 3)
nl1 = spot1.numLines
nl2 = spot2.numLines
nl3 = spot3.numLines
ratio1 = ((xA - x1) / xA)
ratio2 = ((yA - y1) / yA)
ratio3 = (dist - math.sqrt((x1)**2 + (y1)**2))
# loadVector: xc.Vector with the six components of the load:
# xc.Vector([Fx,Fy,Fz,Mx,My,Mz]).
deadLoadKerb = loads.UniformLoadOnLines(name='deadLoadKerb',
xcSet=kerbs,
loadVector=xc.Vector(
[0, 0, -linKerb, 0, 0, 0]))
deadLoadBarr = loads.UniformLoadOnLines(name='deadLoadKerb',
xcSet=barrs,
loadVector=xc.Vector(
[0, 0, -linBarrier, 0, 0, 0]))
# *Traffic loads
# Sets definition
poly_lane_Bern = geom.Polygon2d()
poly_lane_Bern.appendVertex(geom.Pos2d(xList_deck[1], 0))
poly_lane_Bern.appendVertex(geom.Pos2d(xList_deck[1], yList_deck[lastYpos]))
poly_lane_Bern.appendVertex(geom.Pos2d(xList_deck[1] + 3,
yList_deck[lastYpos]))
poly_lane_Bern.appendVertex(geom.Pos2d(xList_deck[1] + 3, 0))
lane_Bern = sets.set_included_in_orthoPrism(preprocessor=prep,
setInit=deck,
prismBase=poly_lane_Bern,
prismAxis='Z',
setName='lane_Bern')
poly_lane_Lausanne = geom.Polygon2d()
poly_lane_Lausanne.appendVertex(geom.Pos2d(xList_deck[1] + 3, 0))
poly_lane_Lausanne.appendVertex(
geom.Pos2d(xList_deck[1] + 3, yList_deck[lastYpos]))
poly_lane_Lausanne.appendVertex(geom.Pos2d(xList_deck[2],
dgDB500S = EHE_materials.B500S.getDiagD(preprocessor)
#Es= dgDB500S.getTangent
# Section geometry
#creation
geomSecHA = preprocessor.getMaterialHandler.newSectionGeometry("geomSecHA")
#filling with regions
regions = geomSecHA.getRegions
#generation of a quadrilateral region of the specified sizes and number of
#divisions for the cells (fibers) generation
rg = regions.newQuadRegion(
EHE_materials.HA25.nmbDiagD
) #name of the quadrilateral region ==(EHE_materials.HA25.nmbDiagD
rg.nDivIJ = 10
rg.nDivJK = 10
rg.pMin = geom.Pos2d(-depth / 2, -width / 2)
rg.pMax = geom.Pos2d(depth / 2, width / 2)
reinforcement = geomSecHA.getReinfLayers
reinforcementInf = reinforcement.newStraightReinfLayer(
EHE_materials.B500S.nmbDiagD)
reinforcementInf.numReinfBars = 2
reinforcementInf.barDiam = 16e-3
reinforcementInf.barArea = areaFi16
reinforcementInf.p1 = geom.Pos2d(cover - depth / 2,
width / 2 - cover) # bottom layer.
reinforcementInf.p2 = geom.Pos2d(cover - depth / 2, cover - width / 2)
reinforcementSup = reinforcement.newStraightReinfLayer(
EHE_materials.B500S.nmbDiagD)
reinforcementSup.numReinfBars = 2
reinforcementSup.barDiam = 16e-3
# -*- coding: utf-8 -*-
from __future__ import print_function
import xc_base
import geom
import math
circ1=geom.Circle2d(geom.Pos2d(0.0,0.0),1.0)
areaCirc=circ1.getArea()
circlePerimeter= circ1.getPerimeter()
circleCenterOfMassX= circ1.getCenterOfMass().x
circleCenterOfMassY= circ1.getCenterOfMass().y
IxCirc=circ1.getIx()
IyCirc=circ1.getIy()
PxyCirc=circ1.getPxy()
ratio1=areaCirc-math.pi
ratio2=(circlePerimeter-2*math.pi)/2*math.pi
ratio3=circleCenterOfMassX
ratio4=circleCenterOfMassY
ratio5=(IxCirc-(math.pi/4.))/(math.pi/4.)
ratio6=(IyCirc-(math.pi/4.))/(math.pi/4.)
ratio7=PxyCirc
import os
fname= os.path.basename(__file__)
if math.fabs(ratio1)<1e-10 and math.fabs(ratio2)<1e-10 and math.fabs(ratio3)<1e-10 and math.fabs(ratio4)<1e-10 and math.fabs(ratio5)<1e-10 and math.fabs(ratio6)<1e-10 and math.fabs(ratio7)<1e-10:
print("test ",fname,": ok.")
else:
print("test ",fname,": ERROR.")
b= 1.0 # Effective width of flange.
bw= 0.25 # Width of the web.
hf= 0.08 # Flange thickness.
d= 0.57 # Effective depth.
diamBar= 22e-3 # Rebar diameter.
areaBar= math.pi*(diamBar/2)**2 # Rebars area.
feProblem= xc.FEProblem()
preprocessor= feProblem.getPreprocessor
concrete= typical_materials.defElasticMaterial(preprocessor, 'concrete',Ec)
steel= typical_materials.defElasticMaterial(preprocessor, "steel",Es)
sectionGeometryTest= preprocessor.getMaterialLoader.newSectionGeometry("sectionGeometryTest")
regiones= sectionGeometryTest.getRegions
flange= regiones.newQuadRegion('concrete')# Flange
flange.pMin= geom.Pos2d(d-hf,0.0)
flange.pMax= geom.Pos2d(d,b)
web= regiones.newQuadRegion('concrete')# Web
web.pMin= geom.Pos2d(0.0,b/2-bw/2)
web.pMax= geom.Pos2d(d-hf,b/2+bw/2)
reinforcement= sectionGeometryTest.getReinfLayers
reinforcementA= reinforcement.newStraightReinfLayer("steel")
reinforcementA.numReinfBars= 5
reinforcementA.barArea= areaBar
reinforcementA.p1= geom.Pos2d(0.0,b/2-bw/2+0.05)
reinforcementA.p2= geom.Pos2d(0.0,b/2+bw/2-0.05)
area= sectionGeometryTest.getAreaHomogenizedSection(Ec)
G= sectionGeometryTest.getCdgHomogenizedSection(Ec)
feProblem= xc.FEProblem()
preprocessor= feProblem.getPreprocessor
# Define materials
concr= EHE_materials.HA25
concr.alfacc=0.85 #f_maxd= 0.85*fcd concrete long term compressive strength factor (normally alfacc=1)
concrMatTag25= concr.defDiagD(preprocessor)
Ec= concr.getDiagD(preprocessor).getTangent
tagB500S= EHE_materials.B500S.defDiagD(preprocessor)
Es= EHE_materials.B500S.getDiagD(preprocessor).getTangent
geomSecHA= preprocessor.getMaterialLoader.newSectionGeometry("geomSecHA")
regiones= geomSecHA.getRegions
concrete= regiones.newQuadRegion(EHE_materials.HA25.nmbDiagD)
concrete.nDivIJ= 10
concrete.nDivJK= 10
concrete.pMin= geom.Pos2d(-depth/2.0,-width/2.0)
concrete.pMax= geom.Pos2d(depth/2.0,width/2.0)
reinforcement= geomSecHA.getReinfLayers
reinforcementInf= reinforcement.newStraightReinfLayer(EHE_materials.B500S.nmbDiagD)
reinforcementInf.numReinfBars= 2
reinforcementInf.barArea= areaFi16
reinforcementInf.p1= geom.Pos2d(cover-depth/2.0,width/2.0-cover) # Armadura inferior.
reinforcementInf.p2= geom.Pos2d(cover-depth/2.0,cover-width/2.0)
reinforcementSup= reinforcement.newStraightReinfLayer(EHE_materials.B500S.nmbDiagD)
reinforcementSup.numReinfBars= 2
reinforcementSup.barArea= areaFi16
reinforcementSup.p1= geom.Pos2d(depth/2.0-cover,width/2.0-cover) # Armadura superior.
reinforcementSup.p2= geom.Pos2d(depth/2.0-cover,cover-width/2.0)
materiales= preprocessor.getMaterialLoader
secHA= materiales.newMaterial("fiber_section_3d","secHA")
def getWFToeEndPosition(self):
''' Returns the position of the toe end in the wireframe model.'''
stemBottomPos = self.getWFStemBottomPosition()
return geom.Pos2d(
stemBottomPos.x - self.bToe - self.stemBottomWidth +
self.stemTopWidth / 2.0, stemBottomPos.y)
respVy = typical_materials.defElasticMaterial(
preprocessor, "respVy", 1e6) # Shear response in y direction.
respVz = typical_materials.defElasticMaterial(
preprocessor, "respVz", 1e3) # Shear response in y direction.
# Section geometry
# setting up
geomSecHA = preprocessor.getMaterialLoader.newSectionGeometry("geomSecHA")
regiones = geomSecHA.getRegions
#filling with regions
rg = regiones.newQuadRegion(
concr.nmbDiagD
) #the name assigned to the region is the string concr.nmbDiagD
rg.nDivIJ = 10
rg.nDivJK = 10
rg.pMin = geom.Pos2d(-width / 2.0, -depth / 2.0)
rg.pMax = geom.Pos2d(width / 2.0, depth / 2.0)
reinforcement = geomSecHA.getReinfLayers
reinforcementInf = reinforcement.newStraightReinfLayer(
EHE_materials.B500S.nmbDiagD)
reinforcementInf.numReinfBars = numBarras
reinforcementInf.barArea = areaBarra
reinforcementInf.p1 = geom.Pos2d(cover - width / 2.0,
cover - depth / 2.0) # Armadura inferior.
reinforcementInf.p2 = geom.Pos2d(width / 2.0 - cover, cover - depth / 2.0)
reinforcementSup = reinforcement.newStraightReinfLayer(
EHE_materials.B500S.nmbDiagD)
reinforcementSup.numReinfBars = numBarras
reinforcementSup.barArea = areaBarra
reinforcementSup.p1 = geom.Pos2d(cover - width / 2.0,
depth / 2.0 - cover) # Armadura superior.
preprocessor = feProblem.getPreprocessor
# Define materials
ela = typical_materials.defElasticMaterial(preprocessor, "ela", E)
# Section geometry
# setting up
geomScc = preprocessor.getMaterialHandler.newSectionGeometry("geomScc")
#filling with regions
regions = geomScc.getRegions
#generation of a quadrilateral region with the specified size and number of
#divisions for the cells (fibers) generation
regEla = regions.newQuadRegion("ela")
regEla.nDivIJ = 11
regEla.nDivJK = 11
regEla.pMin = geom.Pos2d(-depth / 2.0, -width / 2.0)
regEla.pMax = geom.Pos2d(depth / 2.0, width / 2.0)
scc = preprocessor.getMaterialHandler.newMaterial("fiber_section_3d", "scc")
fiberSectionRepr = scc.getFiberSectionRepr()
fiberSectionRepr.setGeomNamed("geomScc")
scc.setupFibers()
ts = scc.getTangentStiffness()
EIz = ts(1, 1)
EIy = ts(2, 2)
EA = ts(0, 0)
EIzTeor = 1 / 12.0 * width * depth**3 * E
ratio1 = (EIz - EIzTeor) / EIzTeor
EIyTeor = 1 / 12.0 * depth * width**3 * E
for i in range(0,11): stepHeight= H/10.0 z= i*stepHeight k= earth_pressure.k_janssen(k0,delta,B,z) sigma_h= k*gammaSoil*z fv= sigma_h*math.tan(delta)*stepHeight Fv+= fv x.append(z) results5_16.append(sigma_h) totalEarthPressure= scipy.integrate.simps(results5_16,x) earthPressurePolygon=geom.Polygon2d() for cx,cy in zip(x,results5_16): earthPressurePolygon.appendVertex(geom.Pos2d(cx,cy)) earthPressurePolygon.appendVertex(geom.Pos2d(x[-1],0.0)) earthPressurePolygon.appendVertex(geom.Pos2d(0,0)) earthPressurePolygonCentroid= earthPressurePolygon.getCenterOfMass() earthPressureVector= geom.Vector2d(-totalEarthPressure,-Fv) earthPressureTail= geom.Pos2d(foundationWidth,H-earthPressurePolygonCentroid.x) earthPressureSVS= geom.SlidingVectorsSystem2d(geom.SlidingVector2d(earthPressureTail,earthPressureVector)) print 'earthPressureSVS: ', earthPressureSVS ''' print 'B/H= 0.1', results5_16 ''' # Spandrel wall. foundationCenter= geom.Pos2d(foundationWidth/2.0,0.0)
I = b * h**3 / 12 # Inertia of the beam section in inches to the fourth power.
x = 0.5 # Relative abscissae where the punctual load is applied.
P = 1e3 # Transverse load.
n = 1e6 # Axial load.
feProblem = xc.FEProblem()
preprocessor = feProblem.getPreprocessor
nodes = preprocessor.getNodeHandler
# Problem type
modelSpace = predefined_spaces.StructuralMechanics2D(nodes)
vReac1 = [0, 0]
vReac2 = [0, 0]
ptoAplic = geom.Pos2d(1 + x * L * math.sqrt(2) / 2,
2 + x * L * math.sqrt(2) / 2) # Load application point.
nodes.defaultTag = 1 #First node number.
nod = nodes.newNodeXY(1, 2)
nod = nodes.newNodeXY(1 + L * math.sqrt(2) / 2, 2 + L * math.sqrt(2) / 2)
# Geometric transformation(s)
lin = modelSpace.newLinearCrdTransf("lin")
# Materials definition
scc = typical_materials.defElasticSection2d(preprocessor, "scc", A, E, I)
# Elements definition
elements = preprocessor.getElementHandler
elements.defaultTransformation = lin.name
elements.defaultMaterial = scc.name
# -*- coding: utf-8 -*- from __future__ import print_function import xc_base import geom import math circ1= geom.Circle2d(geom.Pos2d(0.0,0.0),1.0) alpha= math.radians(0) v= geom.Vector2d(math.cos(alpha),math.sin(alpha)) pol1= circ1.getInscribedPolygon(3,0) ptsTang= pol1.getApproxTangentPositions(v) pt0= ptsTang[0] pt0Teor= geom.Pos2d(-0.125,-0.649519) alpha= math.radians(45) v= geom.Vector2d(math.cos(alpha),math.sin(alpha)) ptsTang= pol1.getApproxTangentPositions(v) pt1Teor= geom.Pos2d(0.4375,-0.32476) pt1= ptsTang[0] alpha= math.radians(90) v= geom.Vector2d(math.cos(alpha),math.sin(alpha)) ptsTang= pol1.getApproxTangentPositions(v) pt2Teor= geom.Pos2d(1,0) pt2= ptsTang[0] alpha= math.radians(135) v= geom.Vector2d(math.cos(alpha),math.sin(alpha)) ptsTang= pol1.getApproxTangentPositions(v) pt3Teor= geom.Pos2d(0.4375,0.32476)
# -*- coding: utf-8 -*-
import xc_base
import geom
pos1 = geom.Pos2d(1, 2)
xPt = pos1.x
yPt = pos1.y
#print("pos1.x= ",pos1.x," pos1.y= ",pos1.y)
import os
fname = os.path.basename(__file__)
if (xPt == 1. and yPt == 2.):
print "test ", fname, ": ok."
else:
print "test ", fname, ": ERROR."
# ^ Y
# |
#
# o o o o
#
# -> Z
#
# o o o o
#
positions = [[-0.5, -0.5], [-0.5, -0.1], [-0.5, 0.1], [-0.5, 0.5], [0.5, -0.5],
[0.5, -0.1], [0.5, 0.1], [0.5, 0.5]]
sectionList = []
for p in positions:
sectionList.append([geom.Pos2d(p[0], p[1]), chsSection])
compoundSection = sp.CompoundSection('CDTrager', sectionList)
fs2dSectionShape = compoundSection.defElasticShearSection2d(
preprocessor, S355JR)
yCenter = compoundSection.yCenterOfMass()
zCenter = compoundSection.zCenterOfMass()
alphaY = compoundSection.alphaY()
ratio1 = (alphaY - 0.5) / 0.5
ratio2 = compoundSection.A() - 8.0 * chsSection.A()
ratio3 = (compoundSection.Iz() - 0.001361296) / 0.001361296
ratio4 = (compoundSection.Iy() - 0.000708496) / 0.000708496
'''
print(yCenter, zCenter)
print('compound A= ', compoundSection.A())
#Parameters for tension stiffening of concrete
paramTS=concrete_base.paramTensStiffness(concrMat=concrete,reinfMat=rfSteel,reinfRatio=ro_s_eff,diagType='K')
concrete.tensionStiffparam=paramTS #parameters for tension stiffening are assigned to concrete
concrDiagram=concrete.defDiagK(preprocessor) #Definition of concrete stress-strain diagram in XC.
# Section geometry (rectangular 0.3x0.5, 20x20 cells)
geomSectFibers= preprocessor.getMaterialHandler.newSectionGeometry("geomSectFibers")
y1= width/2.0
z1= depth/2.0
#concrete region
regions= geomSectFibers.getRegions
concrSect= regions.newQuadRegion(concrete.nmbDiagK)
concrSect.nDivIJ= nDivIJ
concrSect.nDivJK= nDivJK
concrSect.pMin= geom.Pos2d(-y1,-z1)
concrSect.pMax= geom.Pos2d(+y1,+z1)
#reinforcement layers
reinforcement= geomSectFibers.getReinfLayers
#bottom layer (positive bending)
reinfBottLayer= reinforcement.newStraightReinfLayer(rfSteel.nmbDiagK) #Steel stress-strain diagram to use.
reinfBottLayer.numReinfBars= 13
reinfBottLayer.barArea= areaFi26
yBotL=(width-2*coverLat-0.026)/2.0
zBotL=-depth/2.0+coverInf+0.026/2.0
reinfBottLayer.p1= geom.Pos2d(-yBotL,zBotL) # center point position of the starting rebar
reinfBottLayer.p2= geom.Pos2d(yBotL,zBotL) # center point position of the starting rebar
#Section material
#it is a generic section created to be assigned to the elements specified
#Etsdiag=ftdiag/(eydiag-ectdiag)
Etsdiag=paramTS.regresLine()['slope']
#Material for making concrete fibers: concrete02 with tension stiffening
concr= typical_materials.defConcrete02(preprocessor=preprocessor,name='concr',epsc0=concrAux.epsilon0(),fpc=concrAux.fmaxK(),fpcu=0.85*concrAux.fmaxK(),epscu=concrAux.epsilonU(),ratioSlope=0.1,ft=ftdiag,Ets=abs(Etsdiag))
# Section geometry (rectangular 0.3x0.5, 20x20 cells)
geomSectFibers= preprocessor.getMaterialHandler.newSectionGeometry("geomSectFibers")
y1= width/2.0
z1= depth/2.0
#concrete region
regions= geomSectFibers.getRegions
concrSect= regions.newQuadRegion('concr')
concrSect.nDivIJ= nDivIJ
concrSect.nDivJK= nDivJK
concrSect.pMin= geom.Pos2d(-y1,-z1)
concrSect.pMax= geom.Pos2d(+y1,+z1)
#reinforcement bar (1 single rebar, centered in the cross-section )
reinforcement= geomSectFibers.getReinfLayers
reinforcementA= reinforcement.newStraightReinfLayer(rfSteel.nmbDiagK) #Steel stress-strain diagram to use.
reinforcementA.numReinfBars= 1
reinforcementA.barArea= As_calc
reinforcementA.p1= geom.Pos2d(0.0,0.0) # 1 single rebar, centered in the cross-section
#Section material
#it is a generic section created to be assigned to the elements specified
#its stress and strain state is neutral (if we ask this section for stress or strain
#values the result is always 0)
materialHandler= preprocessor.getMaterialHandler
