__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