Arch bridge base

class rough_calculations.arch_bridge_rough_base.ArchBridgeRoughModelBase(L, d)

Bases: object

Base class for arch bridge rough models

Variables:
  • d – rise (depth) of the arch at midspan
  • L – horizontal distance between supports
getQunfHabtm(qunif)

Horizontal reaction at each abutment due to a uniform load.

Parameters:qunif – uniformly distributed load applied to the arch
getQunfVabtm(qunif)

Vertical reaction at each abutment due to a uniform load.

Parameters:qunif – uniformly distributed load applied on the deck

Arch bridge simple model

class rough_calculations.arch_bridge_simple_model.ArchBridgeRoughModel(L, d)

Bases: rough_calculations.arch_bridge_rough_base.ArchBridgeRoughModelBase

Arch bridge simple model

getMmaxQconc(Qconc)

maximum bending moment in a parabolic three hinged arch produced by concentrated live forces placed at quarterspans The bending moment is maximum at the quarterpoints

getQconcCompStress(Qconc, A)

Approximation of the compressive stress in a section of the three hinged arch with area=A, due to a two concentrated loads in quarterpoints. for simplicity, it’s considered the compressive force at the midspan (H, that, in turn, i equal to the horizontal reaction at the abutment) as an approximation for the compressive force in the arch at any location

getQconcHabtm(Qconc)

Horizontal reaction at each abutment of a three hinged arch due to a two concentrated loads in quarterpoints

getQconcVabtm(Qconc)

Vertical reaction at each abutment of a three hinged arch due to two concentrated loads in quarterpoints

getQunfCompStress(qunif, A)

Approximation of the compressive stress in a section of the arch with area=A, due to a uniform load qunif. for simplicity, it’s considered the compressive force at the midspan (H, that, in turn, i equal to the horizontal reaction at the abutment) as an approximation for the compressive force in the arch at any location

Masonry vault

class rough_calculations.masonry_vault.FillingCharacteristics(a=0.5235987755982988, c=0.0, mp=0.33, mc=0.01, alpha=0.726, beta=6.095, swFill=18000.0, swSupStr=20000.0, fillThick=9, eqThickRoad=0.5)

Bases: object

alpha = 0.726
angPhi = 0.5235987755982988
beta = 6.095
cohesion = 0
eqThickRoad = 0.5
fillThick = 9
getKc()
getKp()

coefficient de poussée des terres

mc = 0.01
mp = 0.33
printResults()
swFill = 18000.0
swSupStr = 20000.0
class rough_calculations.masonry_vault.archGeometry(coefPolArch=[0, 0, 0, 0], XRot=[0, 0, 0, 0], arcThick=0, arcSpan=15, arcEffL=4)

Bases: object

Geometric definition of the arc:

Variables:
  • coefPolArch=[f,j,k,r] – Coefficients of polynomial y=fx^4+jx^3+kx^2+rx+u (u=0)
  • XRot=[xA,xB,xC,xD] – X coordinates of the rotules A,B,C,D [m]
  • arcThick – arch thickness [m]
  • arcSpan – arch span [m]
  • arcEffL – effective arch width [m]
aux1(x1, x0)

Aux function.

aux2(x2)

Aux function.

calcGamma(x)

Angle of tangent to arc at x.

check(x_i, y_i)
checkAbscissa(x)
getDistxAB()
getDistxAC()
getDistxBD()
getGammaD()

angle at rotule D

getS()

Rise to span ratio.

getYKeystone()

Y coordinate in keystone of arch (at arcSpan/2)

getYRot()

YRot=[yA,yB,yC,yD]: Y coordinate of rotules A,B,C,D [m]

plot()

Draws the arc and the hinges in matplotlib.

printResults()
yAxis(x)

Polynomial intevrpolation for arc’s axis.

rough_calculations.masonry_vault.calcE6p27(X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA)

Grandeur E pour le changement de variable selon l’equation 6.27

rough_calculations.masonry_vault.calcF6p28(R, LR, a, b, eta, phiS, etaW, psiT, MA, MB, MC, RzB, RzD, hA, hB, hC, hD)

Grandeur F pour le changement de variable selon l’equation 6.28

rough_calculations.masonry_vault.calcG6p29(X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA, gammaD)

Grandeur G pour le changement de variable selon l’equation 6.29

rough_calculations.masonry_vault.calcH6p30(LR, a, eta, psi, phiS, etaW, MA, MB, MC, RzB, hA, hB, hC, hD, gammaD)

Grandeur H pour le changement de variable selon l’equation 6.30

rough_calculations.masonry_vault.calcHA6p19(n, X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA, etaW, MA, MB, MC, RzB, phiS)

Effort horizontal dans la rotule A selon l’equation 6.19

Parameters:
  • n – Multiplicateur limite des charges utiles (voir 6.32)
  • qrep – charge repartie
rough_calculations.masonry_vault.calcHB6p21(n, X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA, etaW, MA, MB, MC, RzB, phiS, R)

Effort horizontal dans la rotule B selon l’equation 6.21

Parameters:
  • n – Multiplicateur limite des charges utiles (voir 6.32)
  • qrep – charge repartie
  • R – Resultante de la force horizontale (voir 6.12 et A 12.1)
rough_calculations.masonry_vault.calcVA6p20(n, X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA, etaW, MA, MB, MC, RzB, phiS)

Effort vertical dans la rotule A selon l’equation 6.20

Parameters:
  • n – Multiplicateur limite des charges utiles (voir 6.32)
  • qrep – charge repartie
rough_calculations.masonry_vault.calcVB6p22(n, X, qrep, L, LR, v, l, a, b, hA, hB, hC, hD, xA, etaW, MA, MB, MC, RzB, phiS, eta)

Effort vertical dans la rotule B selon l’equation 6.22

Parameters:
  • n – Multiplicateur limite des charges utiles (voir 6.32)
  • qrep – charge repartie
rough_calculations.masonry_vault.calcn6p32(alpha, beta, d, v, E, F, G, H)

Multiplicateur de la charge utile.

rough_calculations.masonry_vault.diagInteraction(N, d, v, alpha, beta)

Moment de flexion qui correspond au axil N au diagramme d’interaction.

rough_calculations.masonry_vault.getAdmissibleAxialForce(S)

Normal axial force as in table 8.1.

rough_calculations.masonry_vault.lQtrans(a, delta, hRcle)

Longueur participante pour la charge transversale (voir eqs. 6.16 et 6.17).

class rough_calculations.masonry_vault.permLoadResult(gm, fc)

Bases: object

Permanent load resultants

fc = <rough_calculations.masonry_vault.FillingCharacteristics object>
getEta()

Résultante des charges permanentes sur l’overture active de l’arc (fig. 6.9) [N]

getEtaW()
getPhi()

résultante des charges permanentes solicitant la portion d’arc comprise entre les rotules A et C (fig. 6.9) [N]

getPhiS()

moment de flexion induit par la résultante phi de la charge permanente entre A et C, par rapport à la rotule C (fig. 6.9) [Nm]

getPsi()

résultante des charges permanentes solicitant la portion d’arc comprise entre les rotules D et B (fig. 6.9) [N]

getPsiT()

moment de flexion induit par la résultante psi de la charge permanente entre D et B, par rapport à la rotule D (fig. 6.9) [Nm]

getR()

résultant de la poussée laterale entre les rotules B et D [N]

getRzB()

moment de flexion induit par la résultant de la poussée laterale entre les rotules B et D, par rapport à la rotule B [Nm]

getRzD()

moment de flexion induit par la résultant de la poussée laterale entre les rotules B et D, par rapport à la rotule D [Nm]

gm = <rough_calculations.masonry_vault.archGeometry object>
printResults(fillChar)
class rough_calculations.masonry_vault.resistance(Nadmis, gm, fc, tl, plR, tlR)

Bases: object

getE()
getF()
getG()
getH()
getHA()

Effort horizontal dans la rotule A.

getHB()

Effort horizontal dans la rotule B.

getMadmis()

Moment de flexion admis (voir 5.17 et A 7.15) [Nm]

getMinimFunc(x)
getSafCoef()

Safety coefficient - Multiplicateur limite des charges utiles (voir 6.32)

getVA()

Effort vertical dans la rotule A.

getVB()

Effort vertical dans la rotule B.

minimize()
printResults()
class rough_calculations.masonry_vault.trafficLoad(delta=0.5235987755982988, fillThickKeys=1.5, Q=160000, qrep=5000.0)

Bases: object

Q = 160000
delta = 0.5235987755982988
fillThickKeys = 1.5
qrep = 5000.0
class rough_calculations.masonry_vault.trafficLoadResult(gm, tl)

Bases: object

Traffic load resultants

getX()

Charge de trafic ponctuelle aprés diffusion longitudinale et transversale (voir 6.18) [Pa]

getlQt()
getqtrans()

Uniform traffic load [N/m] after transverse diffusion (see 6-15)

getvQt()
gm = <rough_calculations.masonry_vault.archGeometry object>
printResults()
tl = <rough_calculations.masonry_vault.trafficLoad object>
rough_calculations.masonry_vault.vQtrans(v, delta, hRcle)

Largeur participante pour la charge transversale (voir 6.5 et figure 6.13).

Vault

class rough_calculations.vaults_rough_calc.SphericalDome(sphRadius, alpha)

Bases: object

Rough calculation of a spherical dome

Variables:
  • sphRadius – radius of curvature (spherical radius)
  • alpha – angle from the top of the dome to the bottom of the dome measured along the meridian [radians]
getHoopLinearForce(qVsurf, Phi)

Return the hoop force per unit length

Parameters:
  • qVsurf – surface load over the dome
  • Phi – angle along meridian (from vertical), so that at the peak of dome Phi=0 and at the dome’s edge Phi=alpha [radians]
getHorizSupportReaction(qVsurf)

Return the horizontal linear reaction at the base of the dome due to a uniform surface load qVsurf over the dome

getMeridionalSupportReaction(qVsurf)

Return the meridional linear reaction at the base of the dome due to a uniform surface load qVsurf over the dome

getMeridonialLinearForce(qVsurf, Phi)

Return the meridonial force per unit length

Parameters:
  • qVsurf – surface load over the dome
  • Phi – angle along meridian (from vertical), so that at the peak of dome Phi=0 and at the dome’s edge Phi=alpha [radians]
getPlanRadius()

Return the planar radius of the dome at the base

getRise()

Return the height (or rise) of the dome

getSpan()

Return the span of the dome

getSurfArea()

Return the surface area of the dome

getTensionForceRing(qVsurf)

Return the tension force in the base ring due to a uniform surface load qVsurf over the dome

getVerticalSupportReaction(qVsurf)

Return the vertical linear reaction at the base of the dome due to a uniform surface load qVsurf over the dome

class rough_calculations.vaults_rough_calc.hyparUmbrella(lx, ly, zMax, zSupp, thickness)

Bases: object

Rough calculation of a hyperbolic paraboloid umbrella :ivar lx: size of one tympan (one-fourth of the umbrella) in X direction :ivar ly: size of one tympan (one-fourth of the umbrella) in Y direction :ivar zMax: Z coordinate of the umbrella corner :ivar zSupp: Z coordinate of the umbrella central point (on the support) :ivar thickness: thickness of the shell :ivar k: warping of the hyperbolic paraboloid

getCmax(pz)

return the maximum compression force in edge of umbrella

Parameters:pz – vertical load per unit area of ground projection
getCompStress(pz)

return the maximum compressive stress in the hypar

Parameters:pz – vertical load per unit area of ground projection
getLedge()

return the maximum length of half an umbrella edge

getLvalley()

return the length of the valley in the umbrella

getNxy(pz)

return shearing force in the hypar shell

Parameters:pz – vertical load per unit area of ground projection
getTensStress(pz)

return the maximum tensile stress in the hypar

Parameters:pz – vertical load per unit area of ground projection
getTmax(pz)

return the maximum tension force in edge of umbrella

Parameters:pz – vertical load per unit area of ground projection
getZ(x, y)

return Z coordinate of point (x,y)

Cable stayed_bridge simple model

class rough_calculations.cable_stayed_bridge_simple_model.CableStayedBridgeRoughModel(l1)

Cable stayed bridge simple model

getHCable(q, theta)

Horizontal reaction at tower due to the cable.

getNCable(q, theta)

Axial force in a cable theta: angle of the cable with the deck.

getVCable(q)

Vertical reaction at tower due to the cable.

T beam bridges

rough_calculations.T_beam_bridges_rough_calc.loadDistrCourbon(P, e, distGirdAx)

Estimates the distribution of the live loads among the longitudinal girders according to the Courbon’s theory. In this method the effect of the variation of span is not at all considered. All the longitudinal beams are considered identical.

Parameters:
  • P – total live load
  • e – eccentricity (+ or -) from the axis of the bridge of the live load (or COG of loads in case of multiple loads)
  • n – number of longitudinal girders
  • distGirdAx – list with the distances (+ or -)of all the girders from the axis of the bridge

return list of reactions for each of the longitudinal girders

Beam deflection

rough_calculations.beam_deflection.deflCantBeamMend(l, EI, M)

Maximum deflection in a cantilever beam with a couple moment at the free end

rough_calculations.beam_deflection.deflCantBeamPconcentr(l, EI, P, a)

Maximum deflection in a cantilever beam with a concentrated load at any point

rough_calculations.beam_deflection.deflCantBeamQunif(l, EI, q)

Maximum deflection in a cantilever beam with a uniformly distributed load

rough_calculations.beam_deflection.deflSimplSupBeamMend(l, EI, M)

Maximum deflection in a beam simply supported at ends with a couple moment at the right end

rough_calculations.beam_deflection.deflSimplSupBeamPconcentr(l, EI, P, b)

Maximum deflection in a beam simply supported at ends with a concentrated load at any point

rough_calculations.beam_deflection.deflSimplSupBeamQunif(l, EI, q)

Maximum deflection in a beam simply supported at ends with a uniformly distributed load

rough_calculations.beam_deflection.getFlechaVigaBiapQUnif(l, EI, q)

Beam deflection at mid-span for a simple supported beam under uniform load.

Parameters:
  • l – span.
  • EI – bending stiffness.
  • q – load per unit length (uniform).

Beam

class rough_calculations.ng_beam.Beam(E=1.0, I=1.0, l=1.0)

Bases: object

EI()

Cantilever

class rough_calculations.ng_cantilever.Cantilever(E=1.0, I=1.0, l=1.0)

Bases: rough_calculations.ng_beam.Beam

getBendingMomentUnderConcentratedLoad(P, a, x)
getBendingMomentUnderUniformLoad(q, x)
getDeflectionUnderConcentratedLoad(P, a, x)
getReactionUnderConcentratedLoad(P, a)
getReactionUnderUniformLoad(q)
getShearUnderConcentratedLoad(P, a, x)
getShearUnderUniformLoad(q, x)

Concrete slab

class rough_calculations.ng_concrete_slab.ConcreteSlab(l, L, thickness)

Bases: object

Concrete slab preliminary structural calculations

class rough_calculations.ng_concrete_slab.FourSidesPinnedConcreteSlab(l, L, thickness)

Bases: rough_calculations.ng_concrete_slab.ConcreteSlab

Four sides pinned concrete slab preliminary structural calculations

getMMax(p)

Returns maximum bending moment under the load p

Parameters:p – Total load over the slab.

Note

Formulas from Yvon Lescouarc’h ingénieur.

predimThickness(p)

Returns thickness for a four side supported slab

Parameters:p – Total load over the slab (N/m2).

Note

Formulas from Yvon Lescouarc’h ingénieur.

Column internal forces

rough_calculations.ng_column_loads.getColumnTributaryArea(L1, L2, L3, L4)

Tributary area of a column from the neighbour spans see «Números gordos en el proyecto de estructuras» page 44

Prestressed concrete

Rough calculations related to prestressed concrete (geometry, losses of prestress, …)

rough_calculations.ng_prestressed_concrete.loss_elastic_shortening_concr(Ac, Ic, Ec, Ep, Ap, ec_p, sigma_p_0, M_sw)

return a rough estimation of the loss of prestress in a section due to elastic shortening of concrete.

Parameters:
  • Ac – cross-section area of concrete
  • Ic – moment of inertia of the concrete cross-section
  • Ec – modulus of elasticity of concrete
  • Ep – modulus of elasticity of prestressing steel
  • Ap – area of prestressing steel
  • ec_p – eccentricity of tendon (with respect to COG of concrete section)
  • sigma_p_0 – initial stress in tendon
  • M_sw – bending moment in the section due to self weight
rough_calculations.ng_prestressed_concrete.loss_friction(s, sigma_p_0, alpha_unit, mu, unint_dev)

return a rough estimation of the loss of prestress due to friction.

Parameters:
  • s – cable length from start to section considered
  • sigma_p_0 – initial stress in tendon
  • alpha_unit – mean angular deviation per unit length. E.g.: Assimilating the parabolic profile of the cable to a circular profile the angular deviation is constant in the beam length and can be expressed as: 8*eccentricity_mid_span/Lbeam**2
  • unint_dev – unintentional angular deviation per unit length
class rough_calculations.ng_prestressed_concrete.prestressingWire(p0, p1, p2, x0, xL, y)

Bases: object

alpha(x)
curvature(x)
getForce(x, P)
getIntegratedU(P)
getL()
getPoint(x)
getU(x, P)
trace = None
x0 = 0.0
xL = 1.0
y = 0.0
z(x)
rough_calculations.ng_prestressed_concrete.sigma_concr_tendon_lev(Ac, Ic, Ec, Ep, Ap, ec_p, sigma_p_0, M_sw)

return a rough estimation of the stress in concrete at the level of the tendon.

Parameters:
  • Ac – cross-section area of concrete
  • Ic – moment of inertia of the concrete cross-section
  • Ec – modulus of elasticity of concrete
  • Ep – modulus of elasticity of prestressing steel
  • Ap – area of prestressing steel
  • ec_p – eccentricity of tendon (with respect to COG of concrete section)
  • sigma_p_0 – initial stress in tendon
  • M_sw – bending moment in the section due to self weight

Punching shear

rough_calculations.ng_punching_shear.esfuerzoPunzonamiento(qk, A)

Estimación del esfuerzo de punzonamiento en la losa sobre un pilar (HL.3 números gordos)

Parameters:
  • qk – characteristic total uniform load on the slab or deck.
  • A – column tributary area.
rough_calculations.ng_punching_shear.punzMaximo(fck, d, a, b)

Estimate of the strut strength in the section at the intersection of the support contour with the deck (HL.3 números gordos) (Interpreto que este es el punzonamiento máximo si no vamos a disponer reinforcement de punzonamiento) Si el esfuerzo de punzonamiento es mayor habrá que:

  • Aumentar la escuadría del pilar (lo más barato)
  • Aumentar el depth de la losa (lo más efectivo)
  • Mejorar la resistencia del hormigón
Parameters:
  • fck – characteristic strength of concrete (N/m2)
  • d – effective depth of the floor deck (m)
  • a,b – dimensions of the column (m)

Result is expressed in N

rough_calculations.ng_punching_shear.reinforcementPunz(Vd, fck, d, a, b, h, fyd)
Estimate the punching reinforcement area
computed at the critical perimeter defined to occur at d/2 from the column faces (HL.3 números gordos)
param Vd:Desing value of the punching shear (N)
param fck:characteristic strength of concrete (N/m2)
param fyd:design value of reinforcement steel yield strength (Pa).
param d:effective depth of the floor deck (m)
param h:slab depth (m).
param a,b:dimensions of the column (m)

Result is expressed in m2/m

Reinforced concrete section

class rough_calculations.ng_rc_section.RCSection(tensionRebars, concrete, b, h)

Bases: object

Reinforced concrete section.

b = 0.25
getMR()
getMinReinfAreaUnderFlexion()
getMinReinfAreaUnderTension()
getVR(Nd, Md)
h = 0.25
setReinforcement(tensionRebars)
tensionRebars = None
writeResultCompression(outputFile, Nd, AsTrsv)

Results for compressed rebars.

Parameters:AsTrsv – Rebar area in transverse direction.
writeResultFlexion(outputFile, Nd, Md, Vd)
writeResultStress(outputFile, M)

Cheking of stresses under permanent loads (SIA 262 fig. 31)

writeResultTraction(outputFile, Nd)

Retaining wall

class rough_calculations.ng_basement_wall.BasementWall(name='prb', concreteCover=0.04, stemBottomWidth=0.25, stemTopWidth=0.25, footingThickness=0.25, concrete=None, steel=None)

Bases: rough_calculations.ng_retaining_wall.RetainingWall

Basement retaining wall (propped cantilever).

genMesh(nodes, springMaterials)

Generate finite element mesh.

getSectionIntStem()

Returns RC section for reinforcement at stem interior.

writeResult(pth)

Write reinforcement verification results in LaTeX format.

Diaphragm wall

class rough_calculations.predim_diaphragm_wall.DiaphragmWallRoughModel(digHeight, phreaticLevel, distAnch, firstExcavHeight, distLastAnchExc, unifLoad, distLoadWall)

Bases: object

Class intended to pre-design a diaphragm wall.

Variables:
  • digHeight – maximum digging height [m]
  • phreaticLevel – phreatic level above maximum effective digging height [m]. It will be =0 or negative if phreatic level below maximum excavation level
  • distAnch – maximum distance between anchors [m] (= 0 or negative if no anchors)
  • firstExcavHeight – height of the first phase of excavation (cantilever) [m]
  • distLastAnchExc – distance from the last anchor to the bottom of excavation [m]
  • unifLoad – uniform load on the ground [kN/m2]
  • distLoadWall – distance from the back of the wall to the starting point where uniform load in applied [m]
getEffectDigHeight()

Return the maximum effective digging height

getFffectDistAnch()

Return effective distance between anchors

getWallEmbedmentDepth()

Return a pre-designed embedment depth [m]

getWallThickness()

Return a pre-designed diaphragm wall thickness [m]

printResult()
rough_calculations.predim_diaphragm_wall.side_line(pnt1, pnt2, pnt)

function to determine which side of the line from pnt1=(x1,y1) to pnt2=(x2,y2) a point pnt=(x,y) falls on.

All the points that return a value <0 lie on one side of the line and those that return a value >0 lie in the other side (if =0 -> in the line)

Basement wall

class rough_calculations.ng_retaining_wall.Envelope(yValues)

Bases: object

filterRepeatedValues()

Filter repeated values.

getAbsMaximum()

Return the greatest value positive or negative

getMaximum()

Return the maximum of the positive envelope

getMinimum()

Return the minimum of the negative envelope

update(values)

Update envelopes.

class rough_calculations.ng_retaining_wall.FootingReinforcement(wallGeom, concreteCover, steel)

Bases: rough_calculations.ng_retaining_wall.ReinforcementMap

Footing reinforcement.

bottomFootingIndex = 7
drawSchema(defStrings)

Footing scheme drawing in LaTeX format.

getRCSections(footingSet)

Create reinforced concrete sections for the footing.

Parameters:footingSet – set of the footing elements.
getSectionFootingBottom()

Returns RC section for reinforcement at footing bottom.

getSectionFootingBottomLongitudinal()

Returns RC section for longitudinal reinforcement at footing bottom.

getSectionTopFooting()

Returns RC section for reinforcement on footing top.

longBottomFootingIndex = 8
longTopFootingIndex = 9
skinFootingIndex = 10
topFootingIndex = 3
writeResult(outputFile)

Write reinforcement verification results in LaTeX format.

class rough_calculations.ng_retaining_wall.InternalForces(y, mdEnvelope, vdEnvelope, MdFooting, VdFooting)

Bases: object

Internal forces for a retaining wall obtained.

MdMax(yCoupe)

Max. bending moment (envelope) at height yCoupe.

MdMaxEncastrement(footingThickness)

Bending moment (envelope) at stem base.

MdMaxMidStem(footingThickness)

Max. bending moment (envelope) at the middle of the stem.

MdMin(yCoupe)

Min bending moment (envelope) at height yCoupe.

MdMinMidStem(footingThickness)

Min. bending moment (envelope) at the middle of the stem.

VdMax(yCoupe)

Max. shear (envelope) at height yCoupe.

VdMaxEncastrement(epaisseurEncastrement)

Shear force (envelope) at stem base.

VdMaxMidStem(footingThickness)

Max. shear (envelope) at the middle of the stem.

VdMin(yCoupe)

Min. shear (envelope) at height yCoupe.

VdMinMidStem(footingThickness)

Min. shear (envelope) at the middle of the stem.

clone()
getYStem(hCoupe)
interpolate()
writeGraphic(fileName)

Draws a graphic of internal forces (envelopes) in the wall stem.

class rough_calculations.ng_retaining_wall.ReinforcementMap(concreteCover=0.04, steel=None, rebarFamilyTemplate=None)

Bases: dict

Simplified reinforcement for a cantilever retaining wall.

getBasicAnchorageLength(index, concrete)

Returns basic anchorage length for the reinforcement at “index”.

getReinforcement(index)

Return reinforcement at index.

setReinforcement(index, reinforcement)

Set reinforcement.

class rough_calculations.ng_retaining_wall.RetainingWall(name='prb', concreteCover=0.04, stemBottomWidth=0.25, stemTopWidth=0.25, stemBackSlope=0.0, footingThickness=0.25, concrete=None, steel=None)

Bases: model.geometry.retaining_wall_geometry.CantileverRetainingWallGeometry

Cantilever retaining wall.

Variables:
  • b – wall lenght (defaults to 1.0).
  • numberOfStemSets – number of element sets along the stem height.
  • stemBottomWidth – (float) Stem width at his contact with the footing.
  • stemTopWidth – (float) Stem width at his top.
  • stemBackSlope – (float) Stem back slope expressed as H/V ratio.
  • footingThickness – (float) Thickness of the footing.
b = 1.0
createBackFillPressures(pressureModel, Delta=0.0)

Create backfill earth pressures over the wall.

Parameters:pressureModel – (obj) earth pressure model for the backfill.
createDeadLoad(heelFillDepth, toeFillDepth, rho=2000, grav=9.81)

Create the loads of earth self weigth.

createEarthPressureLoadOnHeelEnd(pressureModel)

Create the loads of the earth pressure over the vertical face at the end of the heel.

Parameters:pressureModel – (obj) earth pressure model.
createEarthPressureLoadOnStem(pressureModel, vDir=<xc.Vector object>, Delta=0.0)

Create the loads of the earth pressure over the stem.

Parameters:
  • pressureModel – (obj) earth pressure model.
  • vDir – (xc.Vector) direction for the pressures.
createEarthPressureLoadOnToeEnd(pressureModel)

Create the loads of the earth pressure over the vertical face at the end of the toe.

Parameters:pressureModel – (obj) earth pressure model.
createFEProblem(title)

Create finite element problem.

createFrontFillPressures(pressureModel, Delta=0.0)

Create front fill earth pressures over the wall.

Parameters:pressureModel – (obj) earth pressure model for the backfill.
createLoadOnTopOfStem(loadVector)

Create a loac acting on the node at the top of the stem.

Parameters:loadVector – (vector) vector defining the load.
createPressuresFromLoadOnBackFill(loadOnBackFill, Delta=0.0)

Create the pressures on the stem and on the heel dues to a load acting on the backfill.

Parameters:loadOnBackFill – (obj) load acting on the backfill.
createRCSections(stemSets)

Create reinforced concrete sections.

Parameters:stemSets – sets of elements along the stem.
createSelfWeightLoads(rho=2500, grav=9.81)

Create the loads of the concrete weight.

createVerticalLoadOnHeel(loadOnBackFill)

Create the loads over the heel dues to a load acting on the backfill.

Parameters:loadOnBackFill – (obj) load acting on the backfill.
drawSchema(pth)

Retaining wall scheme drawing in LaTeX format.

genMesh(nodes, springMaterials)

Generate finite element mesh.

getAdmissiblePressureSafetyFactor(R, sg_adm)

Return the factor of safety against bearing capacity of the soil.

Parameters:
  • R – force on the bearing plane.
  • toeFillDepth – (float) depht of the soil filling over the toe.
  • q_adm – (float) admissible bearing pressure.
getBearingPressure(R)

Return the bearing pressure.

Parameters:
  • R – force on the bearing plane.
  • foundationSoilModel – soil model for the Brinch-Hansen analysis.
  • toeFillDepth – (float) depht of the soil filling over the toe.
  • q – (float) uniform load over the filling.
getBearingPressureSafetyFactor(R, foundationSoilModel, toeFillDepth, q=0.0)

Return the factor of safety against bearing capacity of the soil.

Parameters:
  • R – force on the bearing plane.
  • foundationSoilModel – soil model for the Brinch-Hansen analysis.
  • toeFillDepth – (float) depht of the soil filling over the toe.
  • q – (float) uniform load over the filling.
getEccentricity(R)

Return the eccenctricity of the loads acting on the retaining wall.

Parameters:R – (SlidingVectorsSystem3d) resultant of the loads acting on the retaining wall.
getEnvelopeInternalForces(envelopeMd, envelopeVd, envelopeMdHeel, envelopeVdHeel)
getFoundationRotation()

Returns the rotation of the foundation.

getHeelInternalForces()
getMononobeOkabeDryOverpressure(backFillModel, kv, kh, delta_ad=0, beta=0, Kas=None, g=9.81)

Return overpressure due to seismic action according to Mononobe-Okabe

Parameters:
  • backFillModel – back fill terrain model
  • kv – seismic coefficient of vertical acceleration.
  • kh – seismic coefficient of horizontal acceleration.
  • delta_ad – angle of friction soil - structure.
  • beta – slope inclination of backfill.
getOverturningSafetyFactor(R, gammaR)

Return the factor of safety against overturning.

Parameters:
  • R – (SlidingVectorsSystem3d) resultant of the loads acting on the retaining wall.
  • gammaR – (float) partial resistance reduction factor.
getReactions()

Return the reactions on the foundation.

getSlidingSafetyFactor(R, gammaR, foundationSoilModel)

Return the factor of safety against sliding.

Parameters:
  • R – (SlidingVectorsSystem3d) resultant of the loads acting on the retaining wall.
  • gammaR – partial resistance reduction factor.
  • foundationSoilModel – (FrictionalCohesionalSoil) soil model.
  • gammaMPhi – (float) partial reduction factor for internal friction angle of the soil.
  • gammaMc – (float) partial reduction factor for soil cohesion.
getStemInternalForces()
getStemYCoordinates()
numberOfStemSets = 4
performSLSAnalysis(combinations)

Perform serviceability limit state analysis.

Parameters:combinations – load combinations to use in the analysis.
performStabilityAnalysis(combinations, foundationSoilModel, sg_adm=None)

Perform stability limit state analysis.

Parameters:combinations – load combinations to use in the analysis.
performULSAnalysis(combinations)

Perform ultimate limit state analysis.

Parameters:combinations – load combinations to use in the analysis.
resultComb(nmbComb)

Solution and result retrieval routine.

setSLSInternalForcesEnvelope(wallInternalForces)

Assigns the serviceability limit state infernal forces envelope for the stem.

setULSInternalForcesEnvelope(wallInternalForces)

Assigns the ultimate limit state infernal forces envelope for the stem.

writeDef(pth, outputFile)

Write wall definition in LaTeX format.

writeResult(pth)

Write reinforcement verification results in LaTeX format.

class rough_calculations.ng_retaining_wall.StemReinforcement(wallGeom, concreteCover, steel)

Bases: rough_calculations.ng_retaining_wall.ReinforcementMap

Stem reinforcement.

drawSchema(defStrings)

Stem data for wall scheme drawing in LaTeX format.

extStemBottomIndex = 1
extStemIndex = 2
getRCSections(stemSets)

Create reinforced concrete sections for the stem.

Parameters:stemSets – sets of elements along the stem.
getSectionExtStem(y)

Returns RC section for exterior reinforcement at stem.

getSectionExtStemBottom()

Returns RC section for exterior reinforcement at stem bottom.

getSectionIntStemBottom()

Returns RC section for interior reinforcement at stem bottom.

getSectionStemLongExt()

Returns RC section for loingitudinal reinforcement in stem exterior.

getSectionStemLongInt()

Returns RC section for loingitudinal reinforcement in stem interior.

getSectionStemTop()

Returns RC section for reinforcement at stem top.

intStemBottomIndex = 4
intStemIndex = 5
longExtStemIndex = 11
longIntStemIndex = 12
topSkinIndex = 13
topStemIndex = 6
writeResult(outputFile)

Write stem reinforcement verification results in LaTeX format.

class rough_calculations.ng_retaining_wall.WallSLSResults(internalForces, rotation, rotationComb)

Bases: rough_calculations.ng_retaining_wall.WallULSResults

writeOutput(outputFile, name)

Write results in LaTeX format.

class rough_calculations.ng_retaining_wall.WallStabilityResults(wall, combinations, foundationSoilModel, sg_adm=None, gammaR=1)

Bases: object

writeOutput(outputFile, name)

Write results in LaTeX format.

class rough_calculations.ng_retaining_wall.WallULSResults(internalForces)

Bases: object

rough_calculations.ng_retaining_wall.filterRepeatedValues(yList, mList, vList)

Simple beam

Simple beam formulas.

class rough_calculations.ng_simple_beam.SimpleBeam(E=1.0, I=1.0, l=1.0)

Bases: rough_calculations.ng_beam.Beam

Beam pinned in both ends.

getBendingMomentUnderConcentratedLoad(P, a, x)
getBendingMomentUnderUniformLoad(q, x)
getBendingMomentUnderUniformLoadPartiallyDistributed(q, a, b, x)
getDeflectionUnderConcentratedLoad(P, a, x)
getDeflectionUnderUniformLoad(q, x)
getReaction1UnderConcentratedLoad(P, a)
getReaction1UnderUniformLoadPartiallyDistributed(q, a, b)
getReaction2UnderConcentratedLoad(P, a)
getReaction2UnderUniformLoadPartiallyDistributed(q, a, b)
getReactionUnderUniformLoad(q)
getShearUnderConcentratedLoad(P, a, x)
getShearUnderUniformLoad(q, x)
getShearUnderUniformLoadPartiallyDistributed(q, a, b, x)

Simple bending reinforcement

Simplified routines for design reinforced concrete elements.

rough_calculations.ng_simple_bending_reinforcement.AsSimpleBending(M, fcd, fsd, b, d)
Return the required reinforcement for a rectangular section
subjected to simple bending.
Parameters:
  • M – bending moment to resist.
  • fcd – concrete design compressive strength (absolute value).
  • fsd – steel design yield strength.
  • b – section width.
  • d – section depth.
rough_calculations.ng_simple_bending_reinforcement.Mlim(fcd, b, d)
rough_calculations.ng_simple_bending_reinforcement.Mu(As, fcd, fsd, b, d)

Return the ultimate bending moment of a rectangular section.

Parameters:
  • As – reinforcement area.
  • fcd – concrete design compressive strength.
  • fsd – steel design yield strength.
  • b – section width.
  • d – section effective depth.
rough_calculations.ng_simple_bending_reinforcement.neutralFiberDepth(M, fcd, b, d)

Return the depth of the neutral fiber in a rectangular section.

Parameters:
  • M – bending moment.
  • fcd – concrete design compressive strength.
  • b – section width.
  • d – section effective depth.

Tied arch simple model

class rough_calculations.tied_arch_simple_model.TiedArchBridgeRoughModel(L, d)

Bases: rough_calculations.arch_bridge_rough_base.ArchBridgeRoughModelBase

Tied Arch bridge simple model

Variables:
  • d – rise (depth) of the arch at midspan
  • L – horizontal distance between supports
getAxialForceArch(qunif)

Compressive axial force in the arch due to a uniform load.

Parameters:qunif – uniformly distributed load applied on the deck
getQunfCompStress(qunif, A)

Approximation of the compressive stress in a section of the arch with area=A, due to a uniform load qunif.

getTensionDeck(qunif)

Tension in the deck tie due to a uniform load.

Parameters:qunif – uniformly distributed load applied on the deck

Pile cap

rough_calculations.ng_pile_cap.get2PileCapBottomReinforcementReqArea(b, h, L)

Devuelve el área de reinforcement necesaria para los cercos verticales de un encepado de DOS pilotes (ver números gordos HC.9 page 33).

Parameters:
  • b – pile cap width.
  • h – pile cap thickness.
  • L – pile cap length.
rough_calculations.ng_pile_cap.get2PileCapHorizontalStirrupsReqArea(b, h)

Devuelve el área de reinforcement necesaria para los cercos horizontales de un encepado de DOS pilotes (ver números gordos HC.9 page 33).

Parameters:
  • b – pile cap width.
  • L – pile cap length.
rough_calculations.ng_pile_cap.getCantoMinimoEncepado(diam, D)

Return the minimum depth of the pile cap.

Parameters:
  • diam – Diámetro de la reinforcement del pilar o del pilote (la que sea mayor).
  • D – Diámetro del pilote.
rough_calculations.ng_pile_cap.getMinimalDistBetweenPileAxes(D)

Return the minimal distance between pile axes.

Parameters:D – Diámetro del pilote.
rough_calculations.ng_pile_cap.getPileCapBottomReinforcementReqArea(alpha, Nd, fyd)

Devuelve el área necesaria para la reinforcement inferior del encepado.

Parameters:
  • alpha – Angle between the concrete compressed struts and the horizontal.
  • Nd – Axil de cálculo en el pilote.
rough_calculations.ng_pile_cap.getTensionOn2PileCapBottomReinforcement(v, d, Nd)

Return the tension in the bottom reinforcement of a pile cap with TWO piles (see números gordos HC.9 page 32).

Parameters:
  • v – distance between the column and the pile.
  • d – pile cap effective depth.
  • Nd – Axil de cálculo en la pila.
rough_calculations.ng_pile_cap.getTensionOnPileCapBottomReinforcement(alpha, Nd)

Returns the tension in the inferior reinforcement of the pile cap.

Parameters:
  • alpha – Angle between the concrete compressed struts and the horizontal.
  • Nd – Axil de cálculo en el pilote.

Pile

rough_calculations.ng_pile_cap.get2PileCapBottomReinforcementReqArea(b, h, L)

Devuelve el área de reinforcement necesaria para los cercos verticales de un encepado de DOS pilotes (ver números gordos HC.9 page 33).

Parameters:
  • b – pile cap width.
  • h – pile cap thickness.
  • L – pile cap length.
rough_calculations.ng_pile_cap.get2PileCapHorizontalStirrupsReqArea(b, h)

Devuelve el área de reinforcement necesaria para los cercos horizontales de un encepado de DOS pilotes (ver números gordos HC.9 page 33).

Parameters:
  • b – pile cap width.
  • L – pile cap length.
rough_calculations.ng_pile_cap.getCantoMinimoEncepado(diam, D)

Return the minimum depth of the pile cap.

Parameters:
  • diam – Diámetro de la reinforcement del pilar o del pilote (la que sea mayor).
  • D – Diámetro del pilote.
rough_calculations.ng_pile_cap.getMinimalDistBetweenPileAxes(D)

Return the minimal distance between pile axes.

Parameters:D – Diámetro del pilote.
rough_calculations.ng_pile_cap.getPileCapBottomReinforcementReqArea(alpha, Nd, fyd)

Devuelve el área necesaria para la reinforcement inferior del encepado.

Parameters:
  • alpha – Angle between the concrete compressed struts and the horizontal.
  • Nd – Axil de cálculo en el pilote.
rough_calculations.ng_pile_cap.getTensionOn2PileCapBottomReinforcement(v, d, Nd)

Return the tension in the bottom reinforcement of a pile cap with TWO piles (see números gordos HC.9 page 32).

Parameters:
  • v – distance between the column and the pile.
  • d – pile cap effective depth.
  • Nd – Axil de cálculo en la pila.
rough_calculations.ng_pile_cap.getTensionOnPileCapBottomReinforcement(alpha, Nd)

Returns the tension in the inferior reinforcement of the pile cap.

Parameters:
  • alpha – Angle between the concrete compressed struts and the horizontal.
  • Nd – Axil de cálculo en el pilote.

Isolated footing

class rough_calculations.ng_isolated_footing.IsolatedFooting(B, Nk=10000.0, Sadm=150000.0, FiArmPilar=0.012, Lpilar=0.5)

Bases: object

Rough design of isolated footing.

Variables:
  • B – Footing side dimension (m)
  • Nk – Characteristic value of axial load in pillar (N).
  • FiArmPilar – Column main rebars diameter (m)
  • Lpilar – Column depth (m)
getLaTeXHeader()
getLaTeXResults()
getNearSlopeReductionFactor(beta, d)
Coefficient of reduction of bearing capacity for pinned supported
footing near a slope. Expression proposed by Corté and Garnier (1994)
Parameters:
  • beta – slope angle
  • d – horizontal distance between the slope and the nearest

foundation edge.

getReport()

Suspension bridge simple model

class rough_calculations.suspension_bridge_simple_model.SuspensionBridgeRoughModel(sag, da, Lm, Lb)

Suspension bridge simple model

getCableAxialForceAtMidSpan(q)

Returns the axial force of the cable at the tower

getCableAxialForceAtTower(q)

Returns the axial force of the cable at the tower

getCableSlopeAtTower(q)

Returns the slope (angle) of the cable at the tower

getHb(q)

Horizontal reaction at tower due to the back span.

getHm(q)

Horizontal reaction at tower due to the main span.

getVanchor(q)

Vertical reaction at anchor.

getVb(q)

Vertical reaction at tower due to the main span.

getVm(q)

Vertical reaction at tower due to the main span.

Minimal dimension of abutment support

rough_calculations.ng_min_dim_of_abutment_support.getBminPontAppuiFixe(l, a, soilClass, quakeZone, bridgeClass)

Returns the minimal dimension of abutment support to avoid the risk of bridge deck falling during a quake. See “Évaluation parasismique des ponts-routes existants” Office féderal des routes page 49). l: Deck length. (Distance between free and fixed abutments). a: expansion joint gap soilClass: A, B, C, D or E. quakeZone: ZI, ZII, ZIIa, ZIIIb bridgeClass: COI, COII, COIII

rough_calculations.ng_min_dim_of_abutment_support.getBminPontFlotant(dAbutFixedPoint, soilClass, quakeZone, bridgeClass)

Returns the minimal dimension of abutment support to avoid the risk of bridge deck falling during a quake. See “Évaluation parasismique des ponts-routes existants” Office féderal des routes page 48).

Parameters:
  • dAbutFixedPoint – Distance between the abutment and the fixed point.
  • soilClass – A, B, C, D or E.
  • quakeZone – ZI, ZII, ZIIa, ZIIIb
  • bridgeClass – COI, COII, COIII
rough_calculations.ng_min_dim_of_abutment_support.getLg(soilClass)

From a length greater than de distance “lg” the soil mouvement can be considered as completely uncorrelated.

rough_calculations.ng_min_dim_of_abutment_support.getUgd(soilClass, quakeZone, bridgeClass)

Returns the design value for soil displacement.

Parameters:
  • soilClass – A, B, C, D or E.
  • quakeZone – ZI, ZII, ZIIa, ZIIIb
  • bridgeClass – COI, COII, COIII

Earth pressure

class rough_calculations.ng_earth_pressure.KreyEarthPressurUnderConcentratedLoad(P, a, fi)

Bases: object

P = None
Q = None
a = None
b = None
fi = None
getLateralPressure(y, z)
getRatioY(y, z)
getRatioZ(y, z)
getZLimInf()
getZLimSup()
p_max = None

Profile mechanical properties

rough_calculations.profile_mechanical_prop.Iprofile(h, b, tw, tf, r)

print(mechanical properties of an I-shaped profile)

  • Z: strong axis
  • Y: weak axis
Parameters:
  • h – height
  • b – widht
  • tw – web thickness
  • tf – flange thickness
  • r – radius