public void GeneralBeamFlexuralCapacityTopReturnsNominalValue()
{
double fc = 4000.0;
FlexuralSectionFactory sf = new FlexuralSectionFactory();
IConcreteMaterial mat = GetConcreteMaterial(fc);
List <Point2D> PolyPoints = new List <Point2D>()
{
new Point2D(-6.0, 0.0),
new Point2D(-6.0, 12.0),
new Point2D(6.0, 12.0),
new Point2D(6.0, 0)
};
Rebar thisBar = new Rebar(1.0, new MaterialAstmA615(A615Grade.Grade60));
var coord = new RebarCoordinate(0, 1.0);
List <RebarPoint> RebarPoints = new List <RebarPoint>()
{
new RebarPoint(thisBar, coord)
};
//GetGeneralSection(List<Point2D> PolygonPoints,
//ConcreteMaterial Concrete, List<RebarPoint> RebarPoints, double b_w, double d)
ConcreteSectionFlexure beam = sf.GetGeneralSection(PolyPoints, mat, RebarPoints, 12.0, 9.0);
IStrainCompatibilityAnalysisResult MResult = beam.GetNominalFlexuralCapacity(FlexuralCompressionFiberPosition.Top);
double M_n = MResult.Moment / 12000;
double refValue = 51.32;
double actualTolerance = EvaluateActualTolerance(M_n, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public void ColumnDistributedInteractionReturnsSPCOL_Nominal0_Strains()
{
double b = 16;
double h = 16;
double f_c = 5000;
List <RebarPoint> LongitudinalBars = new List <RebarPoint>();
FlexuralSectionFactory flexureFactory = new FlexuralSectionFactory();
CompressionSectionFactory compressionFactory = new CompressionSectionFactory();
IConcreteMaterial mat = GetConcreteMaterial(f_c);
IRebarMaterial rebarMat = new MaterialAstmA615(A615Grade.Grade60);
ConcreteSectionFlexure flexureMember = flexureFactory.GetRectangularSectionFourSidesDistributed(b, h, 4.0, 0, 2.5, 2.5,
mat, rebarMat, ConfinementReinforcementType.Ties, 1);
ConcreteSectionCompression col = compressionFactory.GetCompressionMemberFromFlexuralSection(flexureMember, CompressionMemberType.NonPrestressedWithTies);
double refForce = 1440;
double refMoment = 43.0;
double SteelStrain = 0.00126;
double P = col.SectionAxialForceResultantFunction(SteelStrain) / 1000.0;
double actualTolerance = EvaluateActualTolerance(P, refForce);
Assert.True(actualTolerance <= tolerance);
}
//Basic calculation
public TensionLapSplice
(
IConcreteMaterial Concrete,
Rebar Bar1,
Rebar Bar2,
bool MeetsRebarSpacingAndEdgeDistance,
bool HasMinimumTransverseReinforcement,
bool IsTopRebar,
TensionLapSpliceClass SpliceClass,
ICalcLog log
)
: base(log)
{
this.Concrete = Concrete;
this.Bar1 = Bar1;
this.Bar2 = Bar2;
this.MeetsRebarSpacingAndEdgeDistance=MeetsRebarSpacingAndEdgeDistance;
this.HasMinimumTransverseReinforcement=HasMinimumTransverseReinforcement;
this.SpliceClass = SpliceClass;
this.IsTopRebar = IsTopRebar;
this.A_tr = A_tr;
this.s_tr = s_tr;
this.n = n;
CalculateValuesBasic();
}
public IConcreteSection GetRectangularSection(double Width, double Height, double fc)
{
IConcreteMaterial mat = GetConcreteMaterial(fc);
CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, Width, Height);
return(section);
}
/// <summary>
/// Calculation of concrete breakout strength of anchor in shear per 17.5.2 of ACI318-14
/// </summary>
/// <param name="n">Number of anchors</param>
/// <param name="nFirstRow">Number of anchors in the direction in the first row parallel to edge</param>
/// <param name="h_eff">Effective embedment depth of anchor</param>
/// <param name="SteelFailureType">Ductile versus brittle failure type for steel anchor</param>
/// <param name="NumberOfEdges">Number of edges locater less than 1.5*h_ef from the anchor</param>
/// <param name="ca_1">Distance from the center of an anchor shaft to the edge of concrete in one direction, in. If shear is applied to anchor, ca1 is taken in the direction of the applied shear. If tension is applied to the anchor, ca1 is the minimum edge distance.</param>
/// <param name="ca_2">Distance from center of an anchor shaft to the edge of concrete in the direction perpendicular to ca_1</param>
/// <param name="s_Max">Maximum spacing between anchors within the group</param>
/// <param name="e_prime_v">Eccentricity</param>
/// <param name="ConcreteCondition">Cracked vs. uncracked concrete</param>
/// <param name="SupplementalReinforcement">Presence of supplemental reinforcement</param>
/// <param name="A_vc">Projected area of the failure surface on the side of the concrete member at its edge for a group of anchors (or single anchor if there's no group effect)</param>
/// <param name="h_a">Thickness of member in which an anchor is located, measured parallel to anchor axis.</param>
/// <param name="IsCastContinuouslyWelded"></param>
/// <param name="lambda"></param>
/// <param name="TypeOfAnchorSleeve">Constant stiffness or separated sleeve (used in calculating l_e per 17.5.2.2) </param>
/// <param name="d_a">Outside diameter of anchor</param>
/// <param name="AnchorType">PostInstalled versus cast in place anchor</param>
public ConcreteBreakoutShear
( IConcreteMaterial Material, int n, int nFirstRow, double h_eff, AnchorSteelElementFailureType SteelFailureType,
int NumberOfEdges, double ca_1, double ca_2, double s_Max, double e_prime_v,
ConcreteCrackingCondition ConcreteCondition, SupplementalReinforcementAtAnchor SupplementalReinforcement, double A_vc,
double h_a, bool IsCastContinuouslyWelded, TypeOfAnchorSleeve TypeOfAnchorSleeve, double d_a,
AnchorInstallationType AnchorType
)
: base(n, h_eff, AnchorType)
{
this.Material = Material;
this.SteelFailureType = SteelFailureType;
this.NumberOfEdges = NumberOfEdges;
this.ca_1 = ca_1;
this.ca_2 = ca_2;
this.s_MAX = s_Max;
this.ev_p = e_prime_v;
this.ConcreteCondition=ConcreteCondition;
this.SupplementalReinforcement = SupplementalReinforcement;
this.A_vc = A_vc;
this.h_a = h_a;
this.nFirstRow = nFirstRow;
this.IsCastContinuouslyWelded = IsCastContinuouslyWelded;
this.TypeOfAnchorSleeve = TypeOfAnchorSleeve;
this.d_a = d_a;
}
//Basic calculation
public TensionLapSplice
(
IConcreteMaterial Concrete,
Rebar Bar1,
Rebar Bar2,
bool MeetsRebarSpacingAndEdgeDistance,
bool HasMinimumTransverseReinforcement,
bool IsTopRebar,
TensionLapSpliceClass SpliceClass,
ICalcLog log
)
: base(log)
{
this.Concrete = Concrete;
this.Bar1 = Bar1;
this.Bar2 = Bar2;
this.MeetsRebarSpacingAndEdgeDistance = MeetsRebarSpacingAndEdgeDistance;
this.HasMinimumTransverseReinforcement = HasMinimumTransverseReinforcement;
this.SpliceClass = SpliceClass;
this.IsTopRebar = IsTopRebar;
this.A_tr = A_tr;
this.s_tr = s_tr;
this.n = n;
CalculateValuesBasic();
}
public CrossSectionGeneralShape(IConcreteMaterial Material, string Name, ISliceableSection SliceableShape, double b_w, double d)
{
this.material = Material;
this._d =d;
this._b_w = b_w;
this.sliceableShape = SliceableShape;
}
public void ColumnDistributedInteractionReturnsSPCOL_Nominal1_Strains()
{
double b = 16;
double h = 16;
double f_c = 5000;
List <RebarPoint> LongitudinalBars = new List <RebarPoint>();
FlexuralSectionFactory flexureFactory = new FlexuralSectionFactory();
CompressionSectionFactory compressionFactory = new CompressionSectionFactory();
IConcreteMaterial mat = GetConcreteMaterial(f_c);
IRebarMaterial rebarMat = new MaterialAstmA615(A615Grade.Grade60);
ConcreteSectionFlexure flexureMember = flexureFactory.GetRectangularSectionFourSidesDistributed(b, h, 4.0, 0, 2.5, 2.5,
mat, rebarMat, ConfinementReinforcementType.Ties, 1);
ConcreteSectionCompression col = compressionFactory.GetCompressionMemberFromFlexuralSection(flexureMember, CompressionMemberType.NonPrestressedWithTies);
double refForce = 1220;
double refMoment = 160.8;
double SteelStrain = 0.000654;
double P = col.SectionAxialForceResultantFunction(SteelStrain) / 1000.0;
double actualTolerance = EvaluateActualTolerance(P, refForce);
//IStrainCompatibilityAnalysisResult momentResult = col.GetNominalMomentResult(refForce, FlexuralCompressionFiberPosition.Top);
//double M_n = momentResult.Moment / 12000.0;
Assert.LessOrEqual(actualTolerance, tolerance);
}
//Detailed calculation
public TensionLapSplice
(
IConcreteMaterial Concrete,
Rebar Bar1,
Rebar Bar2,
double ClearSpacing,
double ClearCover,
bool IsTopRebar,
double A_tr,
double s_tr,
double n,
TensionLapSpliceClass SpliceClass,
ICalcLog log
)
: base(log)
{
this.Concrete =Concrete ;
this.Bar1 =Bar1 ;
this.Bar2 =Bar2 ;
this.ClearSpacing=ClearSpacing;
this.ClearCover =ClearCover ;
this.IsTopRebar = IsTopRebar;
this.A_tr =A_tr ;
this.s_tr =s_tr ;
this.n = n;
this.SpliceClass = SpliceClass;
CalculateValuesDetailed();
}
public void CornerSlabReturnsPunchingShearStressEqualForConfigurations()
{
IConcreteMaterial mat = this.GetConcreteMaterial(4000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.62;
double cx = 20.00;
double cy = 14.0;
Point2D ColumnCenter = new Point2D(0, 0);
//_UpperRight
PunchingPerimeterData data_UpperRight = f.GetPerimeterData(PunchingPerimeterConfiguration.CornerLeftTop, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec_UpperRight = new ConcreteSectionTwoWayShear(data_UpperRight, d, cx, cy, PunchingPerimeterConfiguration.CornerRightTop);
double v_u_UpperRight = sec_UpperRight.GetCombinedShearStressDueToMomementAndShear(0 * 1000, 1326 * 1000, 0, 1.0, 1.0).v_max;
//_LowerLeft
PunchingPerimeterData data_LowerLeft = f.GetPerimeterData(PunchingPerimeterConfiguration.CornerLeftTop, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec_LowerLeft = new ConcreteSectionTwoWayShear(data_LowerLeft, d, cx, cy, PunchingPerimeterConfiguration.CornerLeftBottom);
double v_u_LowerLeft = sec_LowerLeft.GetCombinedShearStressDueToMomementAndShear(0 * 1000, 1326 * 1000, 0, 1.0, 1.0).v_max;
//_LowerRight
PunchingPerimeterData data_LowerRight = f.GetPerimeterData(PunchingPerimeterConfiguration.CornerLeftTop, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec_LowerRight = new ConcreteSectionTwoWayShear(data_LowerRight, d, cx, cy, PunchingPerimeterConfiguration.CornerRightBottom);
double v_u_LowerRight = sec_LowerRight.GetCombinedShearStressDueToMomementAndShear(0 * 1000, 1326 * 1000, 0, 1.0, 1.0).v_max;
//_UpperLeft
PunchingPerimeterData data_UpperLeft = f.GetPerimeterData(PunchingPerimeterConfiguration.CornerLeftTop, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec_UpperLeft = new ConcreteSectionTwoWayShear(data_UpperLeft, d, cx, cy, PunchingPerimeterConfiguration.CornerLeftTop);
double v_u_UpperLeft = sec_UpperLeft.GetCombinedShearStressDueToMomementAndShear(0 * 1000, 1326 * 1000, 0, 1.0, 1.0).v_max;
Assert.Equal(v_u_UpperRight, v_u_LowerLeft);
Assert.Equal(v_u_UpperRight, v_u_LowerRight);
Assert.Equal(v_u_UpperRight, v_u_UpperLeft);
}
public CrossSectionGeneralShape(IConcreteMaterial Material, string Name, ISliceableSection SliceableShape, double b_w, double d)
{
this.material = Material;
this._d = d;
this._b_w = b_w;
this.sliceableShape = SliceableShape;
}
public void RectangularBeamReturnsInteractionValue()
{
double h = 24.0;
double d = 21.5;
double b = 14.0;
double N_u = 0.0;
double V_u = 57100.0;
double T_u = 28.0 * 12000.0;
double fc = 3000.0;
double c_center = 1.75;
bool IsLightWeight = false;
//double phiV_c = beam.GetConcreteShearStrength(N_u, rho_w, M_u, V_u);
IConcreteMaterial mat = GetConcreteMaterial(fc, IsLightWeight);
CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, b, h);
ConcreteSectionOneWayShearNonPrestressed beam = new ConcreteSectionOneWayShearNonPrestressed(d, section);
double phiV_c = beam.GetConcreteShearStrength(0, 0, 0, 0);
ConcreteSectionTorsion tb = GetConcreteTorsionBeam(b, h, fc, d, false, c_center);
double IR = tb.GetMaximumForceInteractionRatio(V_u, T_u, phiV_c, b, d);
double refValue = 326.0 / 411.0; //Example 7-2
double actualTolerance = EvaluateActualTolerance(IR, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public ConcreteSectionFlexure GetRectangularSectionFourSidesDistributed(double b, double h,
double A_sTopBottom, double A_sLeftRight, double c_centTopBottom, double c_centLeftRight, IConcreteMaterial mat, IRebarMaterial rebarMaterial)
{
double YTop = h / 2.0 - c_centTopBottom;
double YBottom = -h / 2.0 + c_centTopBottom;
double XLeft = -b / 2.0 + c_centLeftRight;
double XRight = b / 2.0 - c_centLeftRight;
Point2D P1 = new Point2D(XLeft, YTop);
Point2D P2 = new Point2D(XRight, YTop);
Point2D P3 = new Point2D(XRight, YBottom);
Point2D P4 = new Point2D(XLeft, YBottom);
RebarLine topLine = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false);
RebarLine bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false);
RebarLine leftLine = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true);
RebarLine rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true);
List<RebarPoint> LongitudinalBars = new List<RebarPoint>();
LongitudinalBars.AddRange(topLine.RebarPoints);
LongitudinalBars.AddRange(bottomLine.RebarPoints);
LongitudinalBars.AddRange(leftLine.RebarPoints);
LongitudinalBars.AddRange(rightLine.RebarPoints);
CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, b, h);
CalcLog log = new CalcLog();
ConcreteSectionFlexure sectionFlexure = new ConcreteSectionFlexure(section, LongitudinalBars, log);
return sectionFlexure;
}
public void ColumnDistributedInteractionReturnsSPCOL_Nominal2()
{
double b = 16;
double h = 16;
double f_c = 5000;
List <RebarPoint> LongitudinalBars = new List <RebarPoint>();
FlexuralSectionFactory flexureFactory = new FlexuralSectionFactory();
CompressionSectionFactory compressionFactory = new CompressionSectionFactory();
IConcreteMaterial mat = GetConcreteMaterial(f_c);
IRebarMaterial rebarMat = new MaterialAstmA615(A615Grade.Grade60);
ConcreteSectionFlexure flexureMember = flexureFactory.GetRectangularSectionFourSidesDistributed(b, h, 4.0, 0, 2.5, 2.5,
mat, rebarMat, ConfinementReinforcementType.Ties, 1);
ConcreteSectionCompression col = compressionFactory.GetCompressionMemberFromFlexuralSection(flexureMember,
CompressionMemberType.NonPrestressedWithTies);
double P = 500 * 1000;
double refValue = 369 * 12 * 1000; //from SP column software
double M_n = col.GetNominalMomentResult(P, FlexuralCompressionFiberPosition.Top).Moment;
double phiM_n_KipFt = M_n / 1000.0 / 12.0;
double actualTolerance = EvaluateActualTolerance(M_n, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
//Detailed calculation
public TensionLapSplice
(
IConcreteMaterial Concrete,
Rebar Bar1,
Rebar Bar2,
double ClearSpacing,
double ClearCover,
bool IsTopRebar,
double A_tr,
double s_tr,
double n,
TensionLapSpliceClass SpliceClass,
ICalcLog log
)
: base(log)
{
this.Concrete = Concrete;
this.Bar1 = Bar1;
this.Bar2 = Bar2;
this.ClearSpacing = ClearSpacing;
this.ClearCover = ClearCover;
this.IsTopRebar = IsTopRebar;
this.A_tr = A_tr;
this.s_tr = s_tr;
this.n = n;
this.SpliceClass = SpliceClass;
CalculateValuesDetailed();
}
/// <summary>
/// Calculation of concrete breakout strength of anchor in shear per 17.5.2 of ACI318-14
/// </summary>
/// <param name="n">Number of anchors</param>
/// <param name="nFirstRow">Number of anchors in the direction in the first row parallel to edge</param>
/// <param name="h_eff">Effective embedment depth of anchor</param>
/// <param name="SteelFailureType">Ductile versus brittle failure type for steel anchor</param>
/// <param name="NumberOfEdges">Number of edges locater less than 1.5*h_ef from the anchor</param>
/// <param name="ca_1">Distance from the center of an anchor shaft to the edge of concrete in one direction, in. If shear is applied to anchor, ca1 is taken in the direction of the applied shear. If tension is applied to the anchor, ca1 is the minimum edge distance.</param>
/// <param name="ca_2">Distance from center of an anchor shaft to the edge of concrete in the direction perpendicular to ca_1</param>
/// <param name="s_Max">Maximum spacing between anchors within the group</param>
/// <param name="e_prime_v">Eccentricity</param>
/// <param name="ConcreteCondition">Cracked vs. uncracked concrete</param>
/// <param name="SupplementalReinforcement">Presence of supplemental reinforcement</param>
/// <param name="A_vc">Projected area of the failure surface on the side of the concrete member at its edge for a group of anchors (or single anchor if there's no group effect)</param>
/// <param name="h_a">Thickness of member in which an anchor is located, measured parallel to anchor axis.</param>
/// <param name="IsCastContinuouslyWelded"></param>
/// <param name="lambda"></param>
/// <param name="TypeOfAnchorSleeve">Constant stiffness or separated sleeve (used in calculating l_e per 17.5.2.2) </param>
/// <param name="d_a">Outside diameter of anchor</param>
/// <param name="AnchorType">PostInstalled versus cast in place anchor</param>
public ConcreteBreakoutShear
(IConcreteMaterial Material, int n, int nFirstRow, double h_eff, AnchorSteelElementFailureType SteelFailureType,
int NumberOfEdges, double ca_1, double ca_2, double s_Max, double e_prime_v,
ConcreteCrackingCondition ConcreteCondition, SupplementalReinforcementAtAnchor SupplementalReinforcement, double A_vc,
double h_a, bool IsCastContinuouslyWelded, TypeOfAnchorSleeve TypeOfAnchorSleeve, double d_a,
AnchorInstallationType AnchorType
)
: base(n, h_eff, AnchorType)
{
this.Material = Material;
this.SteelFailureType = SteelFailureType;
this.NumberOfEdges = NumberOfEdges;
this.ca_1 = ca_1;
this.ca_2 = ca_2;
this.s_MAX = s_Max;
this.ev_p = e_prime_v;
this.ConcreteCondition = ConcreteCondition;
this.SupplementalReinforcement = SupplementalReinforcement;
this.A_vc = A_vc;
this.h_a = h_a;
this.nFirstRow = nFirstRow;
this.IsCastContinuouslyWelded = IsCastContinuouslyWelded;
this.TypeOfAnchorSleeve = TypeOfAnchorSleeve;
this.d_a = d_a;
}
/// <summary>
///
/// </summary>
/// <param name="RectangularShape">Rectangular shape</param>
/// <param name="c_transv_ins">Cover to inside face of transverse reinforcement</param>
public TorsionSectionRectangularNonPrestressed(SectionRectangular RectangularShape,
IConcreteMaterial Material, double c_transv_ins)
{
this.RectangularShape = RectangularShape;
this.c_transv_ins = c_transv_ins;
this.IsPrestressed = IsPrestressed;
this.Material = Material;
}
public ReinforcedSectionTwoWayShear(IConcreteMaterial Material, IRebarMaterial Rebar,
PunchingPerimeterData Perimeter, double A_v, double s, PunchingReinforcementType PunchingReinforcementType)
{
this.Material = Material;
this.Perimeter = Perimeter;
this.Rebar = Rebar;
this.A_v = A_v;
this.s = s;
this.PunchingReinforcementType = PunchingReinforcementType;
}
private CrossSectionIShape GetIShape(IConcreteMaterial Material, double h_total, double t_w, BoundaryZone BoundaryZoneTop, BoundaryZone BoundaryZoneBottom)
{
double d = h_total;
double b_fTop = BoundaryZoneTop.b == 0 ? t_w : BoundaryZoneTop.b;
double b_fBot = BoundaryZoneBottom.b == 0 ? t_w : BoundaryZoneBottom.b;
double t_fTop = BoundaryZoneTop.h;
double t_fBot = BoundaryZoneBottom.h;
return(new CrossSectionIShape(Material, null, d, b_fTop, b_fBot, t_fTop, t_fBot, t_w));
}
/// <summary>
/// Concrete generic shape
/// </summary>
/// <param name="PolygonPoints">Points representing closed polyline describing the outline of concrete shape</param>
/// <param name="Concrete">Concrete material</param>
/// <param name="RebarPoints">Points representing vertical rebar. Rebar points have associated rebar material and location</param>
/// <param name="b_w">Section width (required for shear strength calculations)</param>
/// <param name="ConfinementReinforcementType"></param>
/// <param name="d">Distance from tension rebar centroid to the furthermost compressed point (required for shear strength calculations)</param>
/// <returns></returns>
public ConcreteSectionFlexure GetGeneralSection(List <Point2D> PolygonPoints,
IConcreteMaterial Concrete, List <RebarPoint> RebarPoints, double b_w, double d,
ConfinementReinforcementType ConfinementReinforcementType = ConfinementReinforcementType.NoReinforcement)
{
CalcLog log = new CalcLog();
var GenericShape = new PolygonShape(PolygonPoints);
CrossSectionGeneralShape Section = new CrossSectionGeneralShape(Concrete, null, GenericShape, b_w, d);
ConcreteSectionFlexure beam = new ConcreteSectionFlexure(Section, RebarPoints, log, ConfinementReinforcementType);
return(beam);
}
/// <summary>
/// Two-way shear section
/// </summary>
/// <param name="Material">Concrete material</param>
/// <param name="Segments">Shear perimeter segments</param>
/// <param name="d">Effective slab section</param>
/// <param name="b_x">Column dimension (normal to slab edge for edge column)</param>
/// <param name="b_y">Column dimension (parallel to slab edge for edge column)</param>
/// <param name="AtColumnFace">Identifies if the section is adjacent to column face (typical) or away from column face (as is the case with shear studs away from the face)</param>
/// <param name="ColumnType">Identifies if the column is located at the interior, slab edge, or slab corner</param>
public ConcreteSectionTwoWayShear(IConcreteMaterial Material, List<PerimeterLineSegment> Segments, double d,
double b_x, double b_y, bool AtColumnFace, PunchingPerimeterConfiguration ColumnType, Point2D ColumnCenter)
{
this.Material =Material ;
this.Segments =Segments ;
this.d =d ;
this.b_x =b_x ;
this.b_y =b_y ;
this.AtColumnFace=AtColumnFace ;
this.ColumnType = ColumnType ;
this.ColumnCenter = ColumnCenter;
}
/// <summary>
/// Two-way shear section
/// </summary>
/// <param name="Material">Concrete material</param>
/// <param name="Segments">Shear perimeter segments</param>
/// <param name="d">Effective slab section</param>
/// <param name="b_x">Column dimension (normal to slab edge for edge column)</param>
/// <param name="b_y">Column dimension (parallel to slab edge for edge column)</param>
/// <param name="AtColumnFace">Identifies if the section is adjacent to column face (typical) or away from column face (as is the case with shear studs away from the face)</param>
/// <param name="ColumnType">Identifies if the column is located at the interior, slab edge, or slab corner</param>
public ConcreteSectionTwoWayShear(IConcreteMaterial Material, List <PerimeterLineSegment> Segments, double d,
double b_x, double b_y, bool AtColumnFace, PunchingPerimeterConfiguration ColumnType, Point2D ColumnCenter)
{
this.Material = Material;
this.Segments = Segments;
this.d = d;
this.b_x = b_x;
this.b_y = b_y;
this.AtColumnFace = AtColumnFace;
this.ColumnType = ColumnType;
this.ColumnCenter = ColumnCenter;
}
/// <summary>
/// Two-way shear section (constructor used for stress calculation)
/// </summary>
/// <param name="Material">Concrete material</param>
/// <param name="Perimeter">Shear perimeter</param>
/// <param name="d">Effective slab section</param>
/// <param name="c_x">Column dimension (along X axis)</param>
/// <param name="c_y">Column dimension (along Y axis)</param>
/// <param name="ColumnType">Identifies if the column is located at the interior, slab edge, or slab corner</param>
/// <param name="AtColumnFace">Identifies if the section is adjacent to column face (typical) or away from column face (as is the case with shear studs away from the face)</param>
public ConcreteSectionTwoWayShear(IConcreteMaterial Material, PunchingPerimeterData Perimeter, double d,
double c_x, double c_y, PunchingPerimeterConfiguration ColumnType, bool AtColumnFace = true)
{
this.Material = Material;
this.Segments = Perimeter.Segments;
this.d = d;
this.c_x = c_x;
this.c_y = c_y;
this.ColumnType = ColumnType;
this.ColumnCenter = Perimeter.ColumnCentroid;
this.AtColumnFace = AtColumnFace;
cen = PunchingPerimeterCentroid;
CalculatePerimeterProperties();
}
public DevelopmentTension(
IConcreteMaterial Concrete,
Rebar Rebar,
bool MeetsSpacingCritera,
bool IsTopRebar,
double ExcessReinforcementRatio,
bool CheckMinimumLength,
ICalcLog log)
: base(Concrete, Rebar, ExcessReinforcementRatio, log)
{
this.isTopRebar = IsTopRebar;
this.MeetsSpacingCritera = MeetsSpacingCritera;
this.CheckMinimumLength = CheckMinimumLength;
db = Rebar.Diameter;
}
public void ShearFrictionReturnsValue()
{
IConcreteMaterial matC = GetConcreteMaterial(4000, false);
IRebarMaterial m = new MaterialAstmA615(A615Grade.Grade60);
double A_c = 720.0;
double A_v = 4.84;
ConcreteSectionShearFriction sec = new ConcreteSectionShearFriction(ACI.Entities.ShearAndTorsion.ShearFrictionSurfaceType.HardenedNonRoughenedConcrete, matC, A_c, m, A_v, 90, 0);
double phiV_n = sec.GetShearFrictionStrength() / 1000.0; //convert back to ksi units
double refValue = 130.68;
double actualTolerance = EvaluateActualTolerance(phiV_n, refValue);
Assert.True(actualTolerance <= tolerance);
}
public DevelopmentTension(
IConcreteMaterial Concrete,
Rebar Rebar,
bool MeetsSpacingCritera,
bool IsTopRebar,
double ExcessReinforcementRatio,
bool CheckMinimumLength,
ICalcLog log)
: base(Concrete, Rebar, ExcessReinforcementRatio, log)
{
this.isTopRebar = IsTopRebar;
this.MeetsSpacingCritera = MeetsSpacingCritera;
this.CheckMinimumLength = CheckMinimumLength;
db = Rebar.Diameter;
}
public IConcreteTorsionalShape GetShape(ISection Shape, IConcreteMaterial Material, double c_transv_ctr)
{
if (Shape is ISectionRectangular)
{
SectionRectangular RectangularShape = Shape as SectionRectangular;
return(new TorsionSectionRectangularNonPrestressed(RectangularShape, Material, c_transv_ctr));
}
else if (Shape is TorsionSectionGeneric)
{
return(Shape as TorsionSectionGeneric);
}
else
{
throw new Exception("Shape type not supported for torsional analysis.");
}
}
public void SlabPunchingConcentricReturnsValue()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 4.75;
double b_1 = 26.0;
double b_2 = 12.0;
List <PerimeterLineSegment> segments = f.GetPerimeterSegments(PunchingPerimeterConfiguration.Interior, b_1, b_2, d);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(mat, segments, d, b_1, b_2, true, PunchingPerimeterConfiguration.Interior);
double phi_v_c = sec.GetTwoWayStrengthForUnreinforcedConcrete() / 1000.0; //convert to kips
double refValue = 71.3 / d / 95.0; //from example
double actualTolerance = EvaluateActualTolerance(phi_v_c, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public void EdgeSlabReturnsPunchingShearStressFor3SidedPerimeterEdgeLeft()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.62;
double cx = 18.0;
double cy = 18.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData data = f.GetPerimeterData(PunchingPerimeterConfiguration.EdgeLeft, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(data, d, cx, cy, PunchingPerimeterConfiguration.EdgeLeft);
double v_u = sec.GetCombinedShearStressDueToMomementAndShear(0 * 1000, 1720 * 1000, 36000).v_min;
double refValue = -338; //from example (page 19)
double actualTolerance = EvaluateActualTolerance(v_u, refValue);
Assert.True(actualTolerance <= tolerance);
}
public void EdgeSlabReturnsPerimeterJ_yPropertyFor3SidedPerimeterMG()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3500, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.5;
double cx = 12.0;
double cy = 16.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData data = f.GetPerimeterData(PunchingPerimeterConfiguration.EdgeLeft, cx, cy, d, 4.0, 4.0, ColumnCenter);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(data, d, cx, cy, PunchingPerimeterConfiguration.EdgeLeft);
double J_y = sec.GetJy(sec.AdjustedSegments);
double refValue = 13200.0;
double actualTolerance = EvaluateActualTolerance(J_y, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public void InteriorSlabReturnsPerimeter_gamma_vy_Property()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.62;
double cx = 12.0;
double cy = 20.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData data = f.GetPerimeterData(PunchingPerimeterConfiguration.Interior, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(data, d, cx, cy, PunchingPerimeterConfiguration.Interior);
double gamma_vy = sec.Get_gamma_vy(cx + d, cy + d);
double refValue = 0.36; //from example
double actualTolerance = EvaluateActualTolerance(gamma_vy, refValue);
Assert.True(actualTolerance <= tolerance);
}
public void EdgeSlabReturnsPerimeterJ_yPropertyFor3SidedPerimeterEdgeLeft()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.62;
double cx = 18.0;
double cy = 18.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData data = f.GetPerimeterData(PunchingPerimeterConfiguration.EdgeLeft, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(data, d, cx, cy, PunchingPerimeterConfiguration.EdgeLeft);
double J_y = sec.GetJy(sec.AdjustedSegments);
double refValue = 17630; //from example (page 19)
double actualTolerance = EvaluateActualTolerance(J_y, refValue);
Assert.True(actualTolerance <= tolerance);
}
public DevelopmentTension(
IConcreteMaterial Concrete,
Rebar Rebar,
double clearSpacing,
double ClearCover,
bool IsTopRebar,
double ExcessReinforcementRatio,
bool CheckMinimumLength,
ICalcLog log)
: base(Concrete, Rebar, ExcessReinforcementRatio, log)
{
this.isTopRebar = IsTopRebar;
this.ClearCover = ClearCover;
this.clearSpacing = clearSpacing;
this.CheckMinimumLength = CheckMinimumLength;
db = Rebar.Diameter;
}
public DevelopmentTension(
IConcreteMaterial Concrete,
Rebar Rebar,
double clearSpacing,
double ClearCover,
bool IsTopRebar,
double ExcessReinforcementRatio,
bool CheckMinimumLength,
ICalcLog log)
: base (Concrete, Rebar, ExcessReinforcementRatio,log)
{
this.isTopRebar = IsTopRebar;
this.ClearCover = ClearCover;
this.clearSpacing = clearSpacing;
this.CheckMinimumLength = CheckMinimumLength;
db = Rebar.Diameter;
}
public void InteriorSlabReturnsPerimeterJ_yProperty()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 5.62;
double cx = 12.0;
double cy = 20.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData data = f.GetPerimeterData(PunchingPerimeterConfiguration.Interior, cx, cy, d, 0.0, 0.0, ColumnCenter);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(data, d, cx, cy, PunchingPerimeterConfiguration.Interior);
double J_y = sec.GetJy(sec.AdjustedSegments);
double refValue = 27474; //from example (page 19)
double actualTolerance = EvaluateActualTolerance(J_y, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public void SlabPunchingStrengthReturnsValue()
{
IConcreteMaterial mat = this.GetConcreteMaterial(3000, false);
PerimeterFactory f = new PerimeterFactory();
double d = 4.75;
double b_1 = 26.0;
double b_2 = 12.0;
Point2D ColumnCenter = new Point2D(0, 0);
PunchingPerimeterData perimeter = f.GetPerimeterData(PunchingPerimeterConfiguration.Interior, b_1, b_2, d, 0, 0, ColumnCenter);
//ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(mat, perimeter, d, b_1, b_2, true, PunchingPerimeterConfiguration.Interior);
ConcreteSectionTwoWayShear sec = new ConcreteSectionTwoWayShear(mat, perimeter, d, b_1, b_2, PunchingPerimeterConfiguration.Interior);
double phi_v_c = sec.GetTwoWayStrengthForUnreinforcedConcrete() / 1000.0; //convert to kips
double refValue = 71.3 / d / 95.0; //from example
double actualTolerance = EvaluateActualTolerance(phi_v_c, refValue);
Assert.True(actualTolerance <= tolerance);
}
public ConcreteSectionCompression GetConcreteExampleColumnWithDistributed()
{
double b = 16;
double h = 16;
double f_c = 5000;
List <RebarPoint> LongitudinalBars = new List <RebarPoint>();
FlexuralSectionFactory flexureFactory = new FlexuralSectionFactory();
CompressionSectionFactory compressionFactory = new CompressionSectionFactory();
IConcreteMaterial mat = GetConcreteMaterial(f_c);
IRebarMaterial rebarMat = new MaterialAstmA615(A615Grade.Grade60);
ConcreteSectionFlexure flexureMember = flexureFactory.GetRectangularSectionFourSidesDistributed(b, h, 4, 0, 2.5, 2.5, mat, rebarMat);
ConcreteSectionCompression column = compressionFactory.GetCompressionMember(flexureMember, CompressionMemberType.NonPrestressedWithTies);
return(column);
}
public static Dictionary <string, object> OneWayShearStrengthProvidedByConcrete(Concrete.ACI318.General.Concrete.ConcreteMaterial ConcreteMaterial,
double b_w, double d, double h, double N_u = 0.0, double rho_w = 0.0, double M_u = 0.0, double V_u = 0.0, string Code = "ACI318-14")
{
//Default values
double phiV_c = 0;
//Calculation logic:
IConcreteMaterial mat = ConcreteMaterial.Concrete;
CrossSectionRectangularShape shape = new CrossSectionRectangularShape(mat, null, b_w, h);
ConcreteSectionOneWayShearNonPrestressed section = new ConcreteSectionOneWayShearNonPrestressed(d, shape);
phiV_c = section.GetConcreteShearStrength(N_u * 1000.0, rho_w, M_u * 1000.0, V_u * 1000.0) / 1000.0; //default ACI units are psi. Convert to ksi, consistent with Dynamo nodes
return(new Dictionary <string, object>
{
{ "phiV_c", phiV_c }
});
}
public ConcreteBreakoutTension(
IConcreteMaterial Material,
int n,
double h_eff,
double e_p_Nx,
double e_p_Ny,
double ev_p,
double ca_MIN,
double ca_MAX,
double s_MAX,
double A_nc,
AnchorInstallationType AnchorType,
ConcreteCrackingCondition ConcreteCondition,
AnchorQualification AnchorQualification,
double kc_Override,
double gamma_c_NOverwrite,
CastInAnchorageType CastInAnchorageType,
bool HasSupplementalReinforcement
)
: base(n,
h_eff, AnchorType)
{
this.Material = Material;
this.A_nc = A_nc;
this.e_p_Nx =e_p_Nx ;
this.e_p_Ny =e_p_Ny ;
this.ev_p =ev_p ;
this.ca_MIN =ca_MIN ;
this.ca_MAX = ca_MAX;
this.s_MAX = s_MAX;
this.AnchorType=AnchorType ;
this.ConcreteCondition = ConcreteCondition;
this.AnchorQualification = AnchorQualification;
this.kc_Override=kc_Override;
this.gamma_c_NOverwrite = gamma_c_NOverwrite;
this.HasSupplementalReinforcement = HasSupplementalReinforcement;
}
/// <summary>
/// Two-way shear section
/// </summary>
/// <param name="Material">Concrete material</param>
/// <param name="Segments">Shear perimeter segments</param>
/// <param name="d">Effective slab section</param>
/// <param name="b_x">Column dimension (normal to slab edge for edge column)</param>
/// <param name="b_y">Column dimension (parallel to slab edge for edge column)</param>
/// <param name="AtColumnFace">Identifies if the section is adjacent to column face (typical) or away from column face (as is the case with shear studs away from the face)</param>
/// <param name="ColumnType">Identifies if the column is located at the interior, slab edge, or slab corner</param>
public ConcreteSectionTwoWayShear(IConcreteMaterial Material, List<PerimeterLineSegment> Segments, double d,
double b_x, double b_y, bool AtColumnFace, PunchingPerimeterConfiguration ColumnType)
:this(Material,Segments,d,b_x,b_y,AtColumnFace,ColumnType, new Point2D(0.0,0.0))
{
}
public Development(IConcreteMaterial Concrete, Rebar Rebar, double ExcessReinforcementRatio, ICalcLog log)
: this(Concrete, Rebar, log)
{
this.excessFlexureReinforcementRatio = ExcessReinforcementRatio;
}
private Development(IConcreteMaterial Concrete, Rebar Rebar, ICalcLog log)
: base(log)
{
this.conc = Concrete;
this.rebar = Rebar;
}
public StandardHookInTension(IConcreteMaterial Concrete, Rebar Rebar,
ICalcLog log,double ExcessFlexureReinforcementRatio)
: base (Concrete, Rebar, ExcessFlexureReinforcementRatio,log)
{
db = Rebar.Diameter;
}
public CrossSectionRectangularShape(IConcreteMaterial Material, string Name, double Width, double Height )
{
this.material = Material;
shape = new SectionRectangular(Name, Width, Height, new Point2D(0,0));
}
public DevelopmentCompression(IConcreteMaterial Concrete, Rebar Rebar,
ICalcLog log, bool IsConfinedCompressionRebar, double ExcessReinforcementRatio = 1.0)
: base(Concrete, Rebar, ExcessReinforcementRatio, log)
{
this.IsConfinedCompressionRebar = IsConfinedCompressionRebar;
}
public CompressionLapSplice(IConcreteMaterial Concrete, Rebar Rebar,
ICalcLog log): base(log)
{
this.Concrete = Concrete;
this.Rebar = Rebar;
}
