public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionAngle angle,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.angle = angle;
}
public void OpeningCompositeReturnsShearStrengthSpreadsheet()
{
d = 18.24;
t_w = 0.415;
t_deck = 2.0;
t_fill = 3.25;
t_e = 3.25;
b_e = 99.0;
h_0 = 10.0;
a_o = 22.0;
A_sn = 9.15;
Q_n = 16.46;
AiscShapeFactory f = new AiscShapeFactory();
section = f.GetShape("W18X60") as ISectionI;
F_y = 50.0;
f_cPrime = 4.0;
N_studs = 99;
N_o = 4.0;
e = 0.0;
t_r = 0.5;
b_r = 2.0;
CompositeIBeamWebOpening o = new CompositeIBeamWebOpening(section, b_e, t_fill, t_deck, F_y, f_cPrime, N_studs, Q_n,
N_o, a_o, h_0, e, t_r, b_r, Steel.AISC.DeckAtBeamCondition.Parallel, 4.5, 12.0);
double phiV_n = o.GetShearStrength();
double refValue = 95.57;
double actualTolerance = EvaluateActualTolerance(phiV_n, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public FlangeOfBuiltUpI(ISteelMaterial Material, ISectionI s,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material)
{
this.section = s;
double bf = 0;
double tf = 0;
switch (compressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
bf = s.b_fTop;
tf = s.t_fTop;
break;
case FlexuralCompressionFiberPosition.Bottom:
bf = s.b_fTop;
tf = s.t_fTop;
break;
default:
throw new Exception("Compression fiber location different from to or bottom is not supported");
}
base.Overhang = bf;
base.Thickness = tf;
}
public PlateProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionRectangular plate,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.plate = plate;
}
public BeamCopeBase(double c, double d_c, ISectionI Section, ISteelMaterial Material) : base(c, d_c, Section, Material)
{
this.c = c;
this.d_c = d_c;
this.Section = Section;
this.Material = Material;
}
public FlangeOfRolledIShape(ISteelMaterial Material, ISectionI s, ElementLocation location)
: base(Material)
{
double bf = 0;
double tf = 0;
switch (location)
{
case ElementLocation.Top:
bf = s.b_fTop;
tf = s.t_fTop;
break;
case ElementLocation.Bottom:
bf = s.b_fTop;
tf = s.t_fTop;
break;
default:
throw new Exception("Invalid location is specified for I-beam flange");
}
base.Overhang = bf;
base.Thickness = tf;
}
public FlangeOfBuiltUpI(ISteelMaterial Material, ISectionI s,
FlexuralCompressionFiberPosition compressionFiberPosition)
:base(Material)
{
this.section = s;
double bf=0;
double tf=0;
switch (compressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
bf = s.b_fTop;
tf = s.t_fTop;
break;
case FlexuralCompressionFiberPosition.Bottom:
bf = s.b_fTop;
tf = s.t_fTop;
break;
default:
throw new Exception("Compression fiber location different from to or bottom is not supported");
}
base.Overhang = bf;
base.Thickness = tf;
}
public BeamCopeBase(double c, double d_c, ISectionI Section, ISteelMaterial Material)
{
this.c = c;
this.d_c = d_c;
this.Section = Section;
this.Material = Material;
}
/// <summary>
///
/// </summary>
/// <param name="Section">I-section (as shape)</param>
/// <param name="SlabEffectiveWidth"></param>
/// <param name="SlabSolidThickness">Concrete fill</param>
/// <param name="SlabDeckThickness">Metal deck thickness</param>
/// <param name="F_y">Yield stress of shape</param>
/// <param name="f_cPrime">Concrete strength</param>
/// <param name="N_studs">Total number of studs (between point of zero and maximum moment)</param>
/// <param name="Q_n">Stud strength (in shear)</param>
/// <param name="N_o">Number of connectors over opening</param>
/// <param name="a_o">Length of opening</param>
/// <param name="h_o">Height of opening</param>
/// <param name="e">Eccentriciy of opening with repect to neutral axis</param>
/// <param name="t_r">Thickness of reinforcing plate</param>
/// <param name="b_r">Width of reinforcing plate</param>
/// <param name="DeckAtBeamCondition">Orientation of deck over beam </param>
/// <param name="w_rMin">Minimum deck rib width (used in case deck is parallel to beam)</param>
/// <param name="s_r">Deck rib spacing (used in case deck is parallel to beam)</param>
/// <param name="IsSingleSideReinforcement"> Indicates if reinforcement is placed on one side of the web</param>
/// <param name="PlateOffset">Reinforcement plate offset with respect to edge of web opening</param>
public CompositeIBeamWebOpening(ISectionI Section, double SlabEffectiveWidth,
double SlabSolidThickness, double SlabDeckThickness, double F_y, double f_cPrime, double N_studs, double Q_n, double N_o,
double a_o, double h_o, double e, double t_r, double b_r, DeckAtBeamCondition DeckAtBeamCondition, double w_rMin, double s_r,
bool IsSingleSideReinforcement = false, double PlateOffset=0)
: base(Section, a_o, h_o, e, F_y, t_r, b_r, IsSingleSideReinforcement, PlateOffset)
{
if (IsSingleSideReinforcement==false)
{
A_r = t_r * b_r;
}
else
{
A_r = 2.0* t_r * b_r;
}
this.N_o = N_o;
this.N_studs = N_studs;
this.Q_n = Q_n;
SumQ_n = N_studs * Q_n;
this.f_cPrime = f_cPrime;
this.SlabEffectiveWidth=SlabEffectiveWidth;
this.SlabSolidThickness=SlabSolidThickness;
this.SlabDeckThickness = SlabDeckThickness;
this.DeckAtBeamCondition = DeckAtBeamCondition;
this.w_rMin = w_rMin;
this.s_r = s_r;
this.ValuesNeedRecalculation = true;
this.ValuesCalculated = false;
}
public double GetTensionFlangeRuptureStrength(ISectionI ShapeIGross, ISectionI ShapeINet)
{
double phiM_n = -1;
double F_y = Section.Material.YieldStress;
double F_u = Section.Material.UltimateStress;
double S_g = Math.Min(ShapeIGross.S_xBot, ShapeIGross.S_xTop);
SectionIWithFlangeHoles netSec = ShapeINet as SectionIWithFlangeHoles;
if (netSec == null)
{
throw new Exception("Net section shape not recognized");
}
double A_fgB = ShapeIGross.b_fBot * ShapeIGross.t_fBot;
double A_fgT = ShapeIGross.b_fTop * ShapeIGross.t_fTop;
double A_fnB = netSec.b_fBot * netSec.t_fBot - netSec.b_hole * netSec.N_holes;
double A_fnT = netSec.b_fTop * netSec.t_fTop - netSec.b_hole * netSec.N_holes;
double Y_t = GetY_t();
double BotFlangeRuptureMoment = GetNetSectionRuptureStrength(A_fnB, A_fgB, Y_t);
double TopFlangeRuptureMoment = GetNetSectionRuptureStrength(A_fnT, A_fgT, Y_t);
phiM_n = Math.Min(BotFlangeRuptureMoment, TopFlangeRuptureMoment);
return(phiM_n);
}
public static Dictionary <string, object> CompositeIBeamWebOpeningShearStrength(CustomProfile IShape, double b_eff, double h_solid, double h_rib,
double F_y, double fc_prime, double N_anchors, double Q_n, double N_o, double a_o, double h_op, double e_op, double t_r, double b_r,
string HeadedAnchorDeckCondition = "Perpendicular", double w_rMin = 4.0, double s_r = 12.0, bool IsSingleSideReinforcement = false,
double V_u = 0, double M_u = 0)
{
//Default values
double phiV_n = 0;
//Calculation logic:
ISectionI sectionI = IShape.Section as ISectionI;
if (sectionI == null)
{
throw new Exception("Specified shape type is not supported. Provide I-shape object as inputparameter");
}
DeckAtBeamCondition deckCondition;
bool IsValidHeadedAnchorDeckCondition = Enum.TryParse(HeadedAnchorDeckCondition, true, out deckCondition);
if (IsValidHeadedAnchorDeckCondition == false)
{
throw new Exception("Headed anchor position and group factor calculation failed. Invalid string provided for HeadedAnchorDeckCondition.");
}
CompositeIBeamWebOpening op = new CompositeIBeamWebOpening(sectionI, b_eff, h_solid, h_rib, F_y, fc_prime, N_anchors, Q_n, N_o, a_o, h_op, e_op,
t_r, b_r, deckCondition, w_rMin, s_r, IsSingleSideReinforcement);
phiV_n = op.GetShearStrength();
return(new Dictionary <string, object>
{
{ "phiV_n", phiV_n }
});
}
public WebOfSinglySymI(ISteelMaterial Material, ISectionI SectionI,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI)
{
this.SectionI = SectionI;
this.compressionFiberPosition = compressionFiberPosition;
}
public static Dictionary <string, object> SteelIBeamWebOpeningShearStrength(CustomProfile IShape, double F_y, double a_o, double h_op,
double e_op, double t_r, double b_r, bool IsSingleSideReinforcement = false, double V_u = 0, double M_u = 0)
{
//Default values
double phiV_n = 0;
//Calculation logic:
ISectionI sectionI = IShape.Section as ISectionI;
if (sectionI == null)
{
throw new Exception("Specified shape type is not supported. Provide I-shape object as inputparameter");
}
double PlateOffset = 0;
SteelIBeamWebOpening op = new SteelIBeamWebOpening(sectionI, F_y, a_o, h_op, e_op, t_r, b_r, IsSingleSideReinforcement, PlateOffset, M_u, V_u);
phiV_n = op.GetShearStrength();
return(new Dictionary <string, object>
{
{ "phiV_n", phiV_n }
});
}
public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionAngle angle,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.angle = angle;
}
public PlateProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionRectangular plate,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.plate = plate;
}
/// <summary>
///
/// </summary>
/// <param name="Section">I-section (as shape)</param>
/// <param name="SlabEffectiveWidth"></param>
/// <param name="SlabSolidThickness">Concrete fill</param>
/// <param name="SlabDeckThickness">Metal deck thickness</param>
/// <param name="F_y">Yield stress of shape</param>
/// <param name="f_cPrime">Concrete strength</param>
/// <param name="N_studs">Total number of studs (between point of zero and maximum moment)</param>
/// <param name="Q_n">Stud strength (in shear)</param>
/// <param name="N_o">Number of connectors over opening</param>
/// <param name="a_o">Length of opening</param>
/// <param name="h_o">Height of opening</param>
/// <param name="e">Eccentriciy of opening with repect to neutral axis</param>
/// <param name="t_r">Thickness of reinforcing plate</param>
/// <param name="b_r">Width of reinforcing plate</param>
/// <param name="DeckAtBeamCondition">Orientation of deck over beam </param>
/// <param name="w_rMin">Minimum deck rib width (used in case deck is parallel to beam)</param>
/// <param name="s_r">Deck rib spacing (used in case deck is parallel to beam)</param>
/// <param name="IsSingleSideReinforcement"> Indicates if reinforcement is placed on one side of the web</param>
/// <param name="PlateOffset">Reinforcement plate offset with respect to edge of web opening</param>
public CompositeIBeamWebOpening(ISectionI Section, double SlabEffectiveWidth,
double SlabSolidThickness, double SlabDeckThickness, double F_y, double f_cPrime, double N_studs, double Q_n, double N_o,
double a_o, double h_o, double e, double t_r, double b_r, DeckAtBeamCondition DeckAtBeamCondition, double w_rMin, double s_r,
bool IsSingleSideReinforcement = false, double PlateOffset = 0)
: base(Section, a_o, h_o, e, F_y, t_r, b_r, IsSingleSideReinforcement, PlateOffset)
{
if (IsSingleSideReinforcement == false)
{
A_r = t_r * b_r;
}
else
{
A_r = 2.0 * t_r * b_r;
}
this.N_o = N_o;
this.N_studs = N_studs;
this.Q_n = Q_n;
SumQ_n = N_studs * Q_n;
this.f_cPrime = f_cPrime;
this.SlabEffectiveWidth = SlabEffectiveWidth;
this.SlabSolidThickness = SlabSolidThickness;
this.SlabDeckThickness = SlabDeckThickness;
this.DeckAtBeamCondition = DeckAtBeamCondition;
this.w_rMin = w_rMin;
this.s_r = s_r;
this.ValuesNeedRecalculation = true;
this.ValuesCalculated = false;
}
public WebOfSinglySymI(ISteelMaterial Material, ISectionI SectionI,
FlexuralCompressionFiberPosition compressionFiberPosition)
:base(Material,SectionI)
{
this.SectionI = SectionI;
this.compressionFiberPosition = compressionFiberPosition;
}
public BeamISlenderWeb(ISteelSection section, bool IsRolledMember, ICalcLog CalcLog)
: base(section, IsRolledMember, CalcLog)
{
SectionI = this.Section as ISectionI;
if (section == null)
{
throw new SectionWrongTypeException(typeof(ISectionI));
}
GetSectionValues();
}
public BeamISlenderWeb(ISteelSection section, bool IsRolledMember, ICalcLog CalcLog)
: base(section, IsRolledMember, CalcLog)
{
SectionI = this.Section as ISectionI;
if (section == null)
{
throw new SectionWrongTypeException(typeof(ISectionI));
}
GetSectionValues();
}
public IShapeMember(ISteelSection Section, bool IsRolledShape,
FlexuralCompressionFiberPosition compressionFiberPosition)
{
double b;
double tf;
if (Section.Shape is ISectionI)
{
ISectionI sectI = Section.Shape as ISectionI;
switch (compressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
b = sectI.b_fTop;
tf = sectI.t_fTop;
break;
case FlexuralCompressionFiberPosition.Bottom:
b = sectI.b_fBot;
tf = sectI.t_fBot;
break;
default:
throw new CompressionFiberPositionException();
}
//flange compactness
if (IsRolledShape == true)
{
this.FlangeCompactness = new FlangeOfRolledIShape(Section.Material, b / 2.0, tf);
}
else
{
this.FlangeCompactness = new FlangeOfBuiltUpI(Section.Material, sectI, compressionFiberPosition);
}
//web compactness
bool isDoublySymmetric = ShapeISymmetry.IsDoublySymmetric(Section.Shape);
if (isDoublySymmetric == true)
{
WebCompactness = new WebOfDoublySymI(Section.Material, sectI);
}
else
{
WebCompactness = new WebOfSinglySymI(Section.Material, sectI, compressionFiberPosition);
}
}
}
public WebOfDoublySymI(ISteelMaterial Material, ISectionI ISectionI)
:base(Material)
{
this.SectionI = ISectionI;
ISectionI s = ISectionI;
this.Width = s.h_web;
if (this.Width<=0)
{
throw new Exception("Clear web distance cannot be less than or equal to 0");
}
this.Thickness = s.t_w;
}
public WebOfDoublySymI(ISteelMaterial Material, ISectionI ISectionI)
: base(Material)
{
this.SectionI = ISectionI;
ISectionI s = ISectionI;
this.Width = s.h_web;
if (this.Width <= 0)
{
throw new Exception("Clear web distance cannot be less than or equal to 0");
}
this.Thickness = s.t_w;
}
public void E1AReturnsAxialCapacity()
{
//AiscCatalogShape section = new AiscCatalogShape("W14X90", null);
AiscShapeFactory AiscShapeFactory = new AiscShapeFactory();
ISectionI section = (ISectionI)AiscShapeFactory.GetShape("W14X90", ShapeTypeSteel.IShapeRolled);
ISteelMaterial Material = new SteelMaterial(65, 29000);
ISteelSection steelSection = new SteelSectionI(section, Material);
IShapeCompact col = new IShapeCompact(steelSection, true, 19 * 12, 19 * 12, 19 * 12);
double phiPn = col.GetFlexuralBucklingStrength().Value;
Assert.True(phiPn == 903);
}
public double GetFlexuralStrength()
{
double phiM_n = 0.0;
CalcLog log = new CalcLog();
ISection section = Section.Shape;
if (section is SectionRectangular || section is SectionOfPlateWithHoles || section is SectionI)
{
if (section is SectionOfPlateWithHoles)
{
SectionOfPlateWithHoles plateWithHoles = section as SectionOfPlateWithHoles;
double S_g = plateWithHoles.B * Math.Pow(plateWithHoles.H, 2);
double Z_net = plateWithHoles.Z_x;
double Y = 0.9 * this.Section.Material.YieldStress * S_g; //Flexural Yielding
double R = 0.75 * this.Section.Material.UltimateStress * Z_net;
phiM_n = Math.Min(Y, R);
}
else if (section is ISectionI)
{
ISectionI IShape = section as ISectionI;
double R = GetTensionFlangeRuptureStrength(IShape);
if (IsCompactDoublySymmetricForFlexure == false)
{
throw new Exception("Noncompact and singly symmetric I-shapes are not supported for connection checks.");
}
else
{
BeamIDoublySymmetricCompact IBeam = new BeamIDoublySymmetricCompact(Section, this.IsRolled, Log);
double Y = 0.9 * IBeam.GetMajorNominalPlasticMoment();
phiM_n = Math.Min(Y, R);
}
}
else //Rectangle
{
SectionRectangular plate = section as SectionRectangular;
if (plate != null)
{
double Z = plate.Z_x;
double Y = 0.9 * this.Section.Material.YieldStress * Z;
phiM_n = Y;
}
}
}
else
{
throw new Exception("Wrong section type. Only SectionRectangular, SectionOfPlateWithHoles and SectionI are supported.");
}
return(phiM_n);
}
//public bool IsExcentricallyLaterallyConstrained { get; set; }
public virtual double GetTorsionalElasticBucklingStressFe(bool IsEccentricallyLaterallyConstrained)
{
double pi2 = Math.Pow(Math.PI, 2);
double E = Section.Material.ModulusOfElasticity;
double C_w = Section.Shape.C_w;
//double Kz = EffectiveLengthFactorZ;
double Lz = L_ez;
//todo: change shear modulus to be the material property
double G = Section.Material.ShearModulus; //ksi
double J = Section.Shape.J;
double I_x = Section.Shape.I_x;
double I_y = Section.Shape.I_y;
double Fe;
//if (Kz * Lz == 0)
if (Lz == 0)
{
double F_y = this.Section.Material.YieldStress;
return(F_y);
}
else
{
Fe = (pi2 * E * C_w / Math.Pow(Lz, 2) + G * J) * 1 / (I_x + I_y); //(E4-4)
if (IsEccentricallyLaterallyConstrained == false)
{
return(Fe);
}
else
{
if (Section.Shape is ISectionI)
{
ISectionI Ishape = Section.Shape as ISectionI;
double A_g = Ishape.A;
double a = Ishape.d / 2.0;
double r_x = Ishape.r_x;
double r_y = Ishape.r_y;
double P_e = 0.9 * ((Math.Pow(Math.PI, 2) * E * (C_w + I_y * Math.Pow(a, 2)) / (Math.Pow((Lz), 2))) + G * J) / (Math.Pow(r_x, 2) + Math.Pow(r_y, 2) + Math.Pow(a, 2));
double F_eCATB = P_e / A_g;
return(F_eCATB);
}
else
{
return(Fe);
}
}
// return Fe;
}
}
private IShapeCompactness GetCompactness()
{
ISectionI Isec = section as ISectionI;
if (Isec != null)
{
compactness = new ShapeCompactness.IShapeMember(section, IsRolledMember, compressionFiberPosition);
}
else
{
throw new ShapeTypeNotSupportedException(" flexural calculation of I-beam");
}
return(compactness);
}
/// <summary>
/// Base class for all web openings
/// </summary>
/// <param name="Section">Steel Section</param>
/// <param name="a_o">Length of opening</param>
/// <param name="h_o">Depth of opening</param>
/// <param name="e">Eccentricity of opening (positive up)</param>
/// <param name="F_y">Steel shape yield stress</param>
/// <param name="t_r"> Plate thickness of opening reinforcement (top or bottom)</param>
/// <param name="b_r"> Plate width (horizontal dimension in cross-section) for reinforcement</param>
public WebOpeningBase(ISectionI Section, double a_o, double h_o, double e, double F_y, double t_r, double b_r,
bool IsSingleSideReinforcement, double PlateOffset)
{
this.a_o = a_o;
this.h_o = h_o;
this.e = e;
this.F_y = F_y;
this.t_r = t_r;
this.b_r = b_r;
SectionI sec = new SectionI(null, Section.d, Section.b_fTop, Section.t_fTop, Section.t_w);
this.Section = sec;
this.PlateOffset = PlateOffset;
this.IsSingleSideReinforcement = IsSingleSideReinforcement;
}
/// <summary>
/// Base class for all web openings
/// </summary>
/// <param name="Section">Steel Section</param>
/// <param name="a_o">Length of opening</param>
/// <param name="h_o">Depth of opening</param>
/// <param name="e">Eccentricity of opening (positive up)</param>
/// <param name="F_y">Steel shape yield stress</param>
/// <param name="t_r"> Plate thickness of opening reinforcement (top or bottom)</param>
/// <param name="b_r"> Plate width (horizontal dimension in cross-section) for reinforcement</param>
public WebOpeningBase(ISectionI Section, double a_o, double h_o, double e, double F_y, double t_r, double b_r,
bool IsSingleSideReinforcement , double PlateOffset)
{
this.a_o =a_o;
this.h_o =h_o;
this.e = e;
this.F_y = F_y;
this.t_r = t_r;
this.b_r = b_r;
SectionI sec = new SectionI(null, Section.d, Section.b_fTop, Section.t_fTop, Section.t_w);
this.Section = sec;
this.PlateOffset = PlateOffset;
this.IsSingleSideReinforcement = IsSingleSideReinforcement;
}
public virtual double Get_ho()
{
double ho;
ISectionI section = this.Section.Shape as ISectionI;
if (section != null)
{
//ho = section.h_o;
ho = section.d - (section.t_fTop / 2.0 + section.t_fBot / 2.0);
}
else
{
throw new SectionWrongTypeException(typeof(ISectionI));
}
return(ho);
}
public FlexuralMemberIBase(ISteelSection section, bool IsRolledMember, ICalcLog CalcLog)
: base(section, CalcLog)
{
this.isRolledMember = IsRolledMember;
if (!(Section.Shape is IDoubleFlangeMember))
{
throw new SectionWrongTypeException("I-section or Channel");
}
else
{
if (Section.Shape is ISectionI)
{
ISectionI s = Section.Shape as ISectionI;
}
}
}
//Compression Flange Local Buckling F3.2
public double GetCompressionFlangeLocalBucklingCapacity()
{
double M_n = 0.0;
double phiM_n = 0.0;
ISectionI sectionI = Section.Shape as ISectionI;
if (sectionI != null)
{
ShapeCompactness.IShapeMember compactness = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure cClass = compactness.GetFlangeCompactnessFlexure();
if (cClass == CompactnessClassFlexure.Noncompact || cClass == CompactnessClassFlexure.Slender)
{
double lambda = this.GetLambdaCompressionFlange(FlexuralCompressionFiberPosition.Top);
double lambdapf = this.GetLambdapf(FlexuralCompressionFiberPosition.Top);
double lambdarf = this.GetLambdarf(FlexuralCompressionFiberPosition.Top);
//note: section is doubly symmetric so top flange is taken
double Sx = this.Section.Shape.S_xTop;
double Fy = this.Section.Material.YieldStress;
double E = this.Section.Material.ModulusOfElasticity;
//double Zx = Section.SectionBase.Z_x;
if (cClass == CompactnessClassFlexure.Noncompact)
{
double Mp = this.GetMajorNominalPlasticMoment();
M_n = Mp - (Mp - 0.7 * Fy * Sx) * ((lambda - lambdapf) / (lambdarf - lambdapf)); //(F3-1)
}
else
{
double kc = this.Getkc();
M_n = 0.9 * E * kc * Sx / Math.Pow(lambda, 2); //(F3-2)
}
}
else
{
}
if (cClass == CompactnessClassFlexure.Compact)
{
throw new LimitStateNotApplicableException("Flange local buckling");
}
}
phiM_n = 0.9 * M_n;
return(phiM_n);
}
//4.4 EXAMPLE 2: STEEL BEAM WITH
//REINFORCED OPENING
private void SetExample2Values()
{
A_s = 16.2;
d = 18.11;
t_w = 0.39;
h_0 = 11.00;
a_o = 20.0;
s_b = 3.555;
s_t = 3.55;
DeltaA_s = 4.29;
A_sn = 11.91;
AiscShapeFactory f = new AiscShapeFactory();
section = f.GetShape("W18X55") as ISectionI;
F_y = 50.0;
f_cPrime = 3.0;
e = 0.0;
t_r = 0.375;
b_r = 1.75;
}
public double GetTensionFlangeRuptureStrength(ISectionI iShape)
{
double phiM_n = -1;
double F_y = Section.Material.YieldStress;
double F_u = Section.Material.UltimateStress;
double S_g = Math.Min(iShape.S_xBot, iShape.S_xTop);
double Y_t = GetY_t();
if (F_u * A_fn >= Y_t * F_y * A_fg)
{
//LimitStateDoes not apply
return(-1);
}
else
{
double M_n = F_u * A_fn / A_fg * S_g; //F13-1
phiM_n = 0.9 * M_n;
}
return(phiM_n);
}
public FlangeOfRolledIShape(ISteelMaterial Material, ISectionI s, ElementLocation location)
:base(Material)
{
double bf=0;
double tf=0;
switch (location)
{
case ElementLocation.Top:
bf = s.b_fTop;
tf = s.t_fTop;
break;
case ElementLocation.Bottom:
bf = s.b_fTop;
tf = s.t_fTop;
break;
default:
throw new Exception("Invalid location is specified for I-beam flange");
}
base.Overhang = bf;
base.Thickness = tf;
}
public static bool IsDoublySymmetric(ISection section)
{
if (section is ISectionI)
{
ISectionI s = section as ISectionI;
double bfTop = s.b_fTop;
double bfBot = s.b_fBot;
double tfTop = s.t_fTop;
double tfBot = s.t_fBot;
if (bfTop == bfBot && tfTop == tfBot)
{
return(true);
}
else
{
return(false);
}
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
///
/// </summary>
/// <param name="Section">I-section (as shape)</param>
/// <param name="SlabEffectiveWidth"></param>
/// <param name="SlabSolidThickness">Concrete fill</param>
/// <param name="SlabDeckThickness">Metal deck thickness</param>
/// <param name="F_y">Yield stress of shape</param>
/// <param name="f_cPrime">Concrete strength</param>
/// <param name="N_studs">Total number of studs (between point of zero and maximum moment)</param>
/// <param name="Q_n">Stud strength (in shear)</param>
/// <param name="N_o">Number of connectors over opening</param>
/// <param name="a_o">Length of opening</param>
/// <param name="h_o">Height of opening</param>
/// <param name="e">Eccentriciy of opening with repect to neutral axis</param>
/// <param name="t_r">Thickness of reinforcing plate</param>
/// <param name="b_r">Width of reinforcing plate</param>
/// <param name="DeckAtBeamCondition">Orientation of deck over beam </param>
/// <param name="w_rMin">Minimum deck rib width (used in case deck is parallel to beam)</param>
/// <param name="s_r">Deck rib spacing (used in case deck is parallel to beam)</param>
/// <param name="IsSingleSideReinforcement"> Indicates if reinforcement is placed on one side of the web</param>
/// <param name="PlateOffset">Reinforcement plate offset with respect to edge of web opening</param>
public CompositeIBeamWebOpening(ISectionI Section, double SlabEffectiveWidth,
double SlabSolidThickness, double SlabDeckThickness, double F_y, double f_cPrime, double N_studs, double Q_n, double N_o,
double a_o, double h_o, double e, double t_r, double b_r, DeckAtBeamCondition DeckAtBeamCondition, double w_rMin, double s_r,
bool IsSingleSideReinforcement = false, double PlateOffset = 0, double M_u = 0, double V_u = 0)
: base(Section, a_o, h_o, e, F_y, t_r, b_r, IsSingleSideReinforcement, PlateOffset, M_u, V_u)
{
if (IsSingleSideReinforcement == true)
{
A_r = t_r * b_r;
double A_f_top = Section.b_fTop * Section.t_fTop;
double A_f_bot = Section.b_fBot * Section.t_fBot;
if (A_r > A_f_top / 3.0 || A_r > A_f_bot / 3.0)
{
throw new Exception("Reinforcement area cannot exceed A_f/3");
}
}
else
{
A_r = 2.0 * t_r * b_r;
}
this.N_o = N_o;
this.N_studs = N_studs;
this.Q_n = Q_n;
SumQ_n = N_studs * Q_n;
this.f_cPrime = f_cPrime;
this.SlabEffectiveWidth = SlabEffectiveWidth;
this.SlabSolidThickness = SlabSolidThickness;
this.SlabDeckThickness = SlabDeckThickness;
this.DeckAtBeamCondition = DeckAtBeamCondition;
this.w_rMin = w_rMin;
this.s_r = s_r;
this.ValuesNeedRecalculation = true;
this.ValuesCalculated = false;
}
public BeamUncoped(ISectionI Section, ISteelMaterial Material)
{
this.Section = Section;
this.Material = Material;
}
public BeamUncoped(ISectionI Section, ISteelMaterial Material)
{
}
public double GetTensionFlangeRuptureStrength(ISectionI iShape)
{
double phiM_n = -1;
double F_y = Section.Material.YieldStress;
double F_u = Section.Material.UltimateStress;
double S_g = Math.Min(iShape.S_xBot, iShape.S_xTop);
double Y_t = GetY_t();
if (F_u*A_fn>=Y_t*F_y*A_fg)
{
//LimitStateDoes not apply
return -1;
}
else
{
double M_n = F_u * A_fn / A_fg * S_g; //F13-1
phiM_n = 0.9 * M_n;
}
return phiM_n;
}
public BeamCopeSingle(double c, double d_c, ISectionI Section, ISteelMaterial Material):
base(c,d_c,Section,Material)
{
}
private ISteelBeamFlexure CreateIBeam(CompactnessClassFlexure FlangeCompactness,
CompactnessClassFlexure WebCompactness, ISectionI Section, ISteelMaterial Material,
ICalcLog Log, bool IsRolled)
{
SteelSectionI steelSection = new SteelSectionI(Section, Material);
ISteelBeamFlexure beam = null;
if (FlangeCompactness== CompactnessClassFlexure.Compact && WebCompactness == CompactnessClassFlexure.Compact)
{
//F2
beam = new BeamIDoublySymmetricCompact(steelSection, IsRolled, Log);
}
else if (WebCompactness == CompactnessClassFlexure.Compact && FlangeCompactness!= CompactnessClassFlexure.Compact)
{
//F3
throw new NotImplementedException();
}
return beam;
}
public SteelSectionI(ISectionI Section, ISteelMaterial Material)
:base(Material)
{
this.section = Section;
}
public ColumnFlangeSplice(ISectionI Section, double F_y, double g)
{
this.Section = Section;
this.g = g;
this.F_y = F_y;
}
public BeamCopeSingle(double c, double d_c, ISectionI Section, ISteelMaterial Material) :
base(c, d_c, Section, Material)
{
}
public SteelSectionI(ISectionI Section, ISteelMaterial Material)
: base(Material)
{
this.section = Section;
}
