protected override LinearStrainDistribution GetInitialStrainEstimate(FlexuralCompressionFiberPosition CompressionFiberPosition)
{
currentCompressionFiberPosition = CompressionFiberPosition; //store this off for getting iteration limits
double StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition);
double c = StrainDistributionHeight * 0.6;
//this is AASHTO criteria for when it's OK to use assumption that
//mild rebar yields, beyond that need to use strain compatibility
double epsilon_c = StrainUltimateConcrete.Value;
double epsilon_s = epsilon_c - (epsilon_c / c) * StrainDistributionHeight;
LinearStrainDistribution strainDistribution = null;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_c, epsilon_s);
break;
case FlexuralCompressionFiberPosition.Bottom:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_s, epsilon_c);
break;
default:
throw new CompressionFiberPositionException();
}
return strainDistribution;
}
public virtual SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
{
double phiM_n = GetYieldingMomentCapacity(CompressionLocation);
SteelLimitStateValue ls = new SteelLimitStateValue(phiM_n, true);
return(ls);
}
public virtual SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation,
FlexuralAndTorsionalBracingType BracingType)
{
SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
return(ls);
}
public double GetWebLocalBucklingCapacity(MomentAxis MomentAxis,
FlexuralCompressionFiberPosition CompressionLocation)
{
double M_n = 0.0;
double S;
double Mp;
if (MomentAxis ==MomentAxis.XAxis)
{
Mp = GetMajorNominalPlasticMoment();
S = Math.Min(Section.Shape.S_yLeft, Section.Shape.S_yRight);
}
else if (MomentAxis == MomentAxis.YAxis)
{
Mp = GetMinorNominalPlasticMoment();
S = Math.Min(Section.Shape.S_xTop, Section.Shape.S_xBot);
}
else
{
throw new FlexuralBendingAxisException();
}
double lambdaWeb = GetLambdaWeb(CompressionLocation,MomentAxis);
M_n = Mp - (Mp - Fy * S) * (0.305 * lambdaWeb * Math.Sqrt(Fy / E) - 0.738); //(F7-5)
M_n = M_n > Mp ? Mp : M_n;
double phiM_n = 0.9 * M_n;
return phiM_n;
}
public override SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation,
FlexuralAndTorsionalBracingType BracingType)
{
CompactnessClassFlexure StemCompactness = this.Compactness.GetWebCompactnessFlexure() ;
// for compact angles this limit state is not applicable
SteelLimitStateValue ls = null;
if (StemCompactness == General.Compactness.CompactnessClassFlexure.Compact)
{
ls = new SteelLimitStateValue(-1, false);
return ls;
}
else if (StemCompactness == CompactnessClassFlexure.Noncompact)
{
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//F10-7
double M_n = F_y * S_c * (2.43 - 1.72 * (((b) / (t))) * Math.Sqrt(((F_y) / (E))));
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
else
{
double F_cr = ((0.71 * E) / (Math.Pow((((b) / (t))), 2)));
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//(F10-8)
double M_n = F_cr * S_c;
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
return ls;
}
protected double GetCompressionBlockDepth(double RebarResultant, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double fc = Section.Material.SpecifiedCompressiveStrength;
double RequiredConcreteArea = 0;
IMoveableSection compressedSection = null;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
RequiredConcreteArea = RebarResultant / (0.85 * fc);
compressedSection = this.Section.SliceableShape.GetTopSliceOfArea(RequiredConcreteArea);
break;
case FlexuralCompressionFiberPosition.Bottom:
RequiredConcreteArea = RebarResultant / (0.85 * fc);
compressedSection = this.Section.SliceableShape.GetBottomSliceOfArea(RequiredConcreteArea);
break;
default:
throw new CompressionFiberPositionException();
}
//Get corresponding strain
double a = compressedSection.YMax - compressedSection.YMin;
return a;
}
public SinglySymmetricIBeam(ISteelSection section, bool IsRolledMember, FlexuralCompressionFiberPosition compressionFiberPosition, ICalcLog CalcLog)
{
this.section = section;
this.IsRolledMember = IsRolledMember;
this.CalcLog = CalcLog;
this.compressionFiberPosition = compressionFiberPosition;
}
public override SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation,
FlexuralAndTorsionalBracingType BracingType)
{
CompactnessClassFlexure StemCompactness = this.Compactness.GetWebCompactnessFlexure();
// for compact angles this limit state is not applicable
SteelLimitStateValue ls = null;
if (StemCompactness == General.Compactness.CompactnessClassFlexure.Compact)
{
ls = new SteelLimitStateValue(-1, false);
return(ls);
}
else if (StemCompactness == CompactnessClassFlexure.Noncompact)
{
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//F10-7
double M_n = F_y * S_c * (2.43 - 1.72 * (((b) / (t))) * Math.Sqrt(((F_y) / (E))));
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
else
{
double F_cr = ((0.71 * E) / (Math.Pow((((b) / (t))), 2)));
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//(F10-8)
double M_n = F_cr * S_c;
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
return(ls);
}
protected ForceMomentContribution GetRebarResultant(LinearStrainDistribution StrainDistribution, ResultantType resType
, FlexuralCompressionFiberPosition p)
{
ForceMomentContribution resultant = new ForceMomentContribution();
//tension is negative
List <RebarPointResult> RebarResults = CalculateRebarResults(StrainDistribution, p);
foreach (var barResult in RebarResults)
{
if (resType == ResultantType.Tension)
{
if (barResult.Strain < 0)
{
resultant.Force += barResult.Force;
resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis;
}
}
else
{
if (barResult.Strain > 0)
{
resultant.Force += barResult.Force;
resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis;
}
}
}
resultant.RebarResults = RebarResults;
return(resultant);
}
public PlateProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionRectangular plate,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.plate = plate;
}
private LinearStrainDistribution GetStrainMaxTensionMaxCompression(FlexuralCompressionFiberPosition CompressionFiberPosition)
{
//Calulate limit strain for the lowest rebar point
//Distinguish between top and bottom tension cases
double StrainDistributionHeight = 0.0;
//double MaxStrain = CalculateMaximumSteelStrain(CompressionFiberPosition);
double MaxStrain = this.MaxSteelStrain;
LinearStrainDistribution MaxMaxDistribution;
StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition);
if (CompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
{
var LowestPointY = LongitudinalBars.Min(yVal => yVal.Coordinate.Y);
var PointsAtLowestY = LongitudinalBars.Where(point => point.Coordinate.Y == LowestPointY).Select(point => point);
var LimitStrain = PointsAtLowestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
MaxStrain = LimitStrain;
MaxMaxDistribution = new LinearStrainDistribution
(StrainDistributionHeight, this.MaxConcreteStrain, -MaxStrain);
}
else
{
var HighestPointY = LongitudinalBars.Max(yVal => yVal.Coordinate.Y);
var PointsAtHighestY = LongitudinalBars.Where(point => point.Coordinate.Y == HighestPointY).Select(point => point);
var LimitStrain = PointsAtHighestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
MaxStrain = LimitStrain;
MaxMaxDistribution = new LinearStrainDistribution
(StrainDistributionHeight, -MaxStrain, this.MaxConcreteStrain);
}
return MaxMaxDistribution;
}
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 double Gethc(FlexuralCompressionFiberPosition compressionFiberPosition)
{
//hc - Twice the distance from the center of gravity to the following:
//the inside face of the compression flange less the fillet or corner
//radius, for rolled shapes; the nearest line of fasteners at the
//compression flange or the inside faces of the compression flange
//when welds are used, for built-up sections, in. (mm) B4.1 (b)
double hc = 0.0;
double k = Getk();
double dsection = GetHeight();
double yCentroid = Section.Shape.y_Bar;
switch (compressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
double tfTop = Get_tfTop();
hc = 2.0 * (dsection - yCentroid - tfTop - k);
break;
case FlexuralCompressionFiberPosition.Bottom:
double tfBot = Get_tfBottom();
hc = 2.0 * (yCentroid - tfBot - k);
break;
default:
throw new Exception("Compression Flange not defined for I-shape and Channel weak axis bending");
}
return hc;
}
public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionAngle angle,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.angle = angle;
}
public ChannelMember(ISteelSection Section, bool IsRolledShape,
FlexuralCompressionFiberPosition compressionFiberPosition)
{
double b;
double tf;
if (Section.Shape is ISectionChannel)
{
ISectionChannel sectChannel = Section.Shape as ISectionChannel;
switch (compressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
b = sectChannel.b_f;
tf = sectChannel.t_f;
break;
case FlexuralCompressionFiberPosition.Bottom:
b = sectChannel.b_f;
tf = sectChannel.t_f;
break;
default:
throw new CompressionFiberPositionException();
}
//flange compactness
FlangeCompactness = new FlangeOfChannel(Section.Material, b / 2.0, tf);
//web compactness
WebCompactness = new WebOfChannel(Section.Material, sectChannel);
}
}
public bool CheckAllowableMoment(FlexuralCompressionFiberPosition CompressionFiberPosition,
double ExternalMoment, StageType Stage, LoadType LoadType)
{
double fct = GetAllowableTension(Stage);
double fcc = GetAllowableCompression(Stage, LoadType);
double M = Math.Abs(ExternalMoment);
double e = GetPrestressingForceEccentricityAtTransfer();
double P = Math.Abs(GetPrestressForceAtTransfer());
double ft = getTopStress(P, e, ExternalMoment, CompressionFiberPosition);
double fb = getBottomStress(P, e, ExternalMoment, CompressionFiberPosition);
double MaxPosForce = Math.Max(ft, fb); //positive is for compression
double MaxNegForce = Math.Min(ft, fb); //positive is for compression
if (MaxPosForce <= fcc && MaxNegForce >= -fct)
{
return(true);
}
else
{
return(false);
}
}
public double GetLambdaCompressionFlange(FlexuralCompressionFiberPosition compressionFiberPosition)
{
compactness = new ShapeCompactness.IShapeMember
(this.Section, this.isRolledMember, compressionFiberPosition);
return compactness.GetCompressionFlangeLambda();
}
public double getMaximumAllowableMoment(FlexuralCompressionFiberPosition CompressionFiberPosition, StageType Stage, LoadType LoadType)
{
double e = GetPrestressingForceEccentricityAtTransfer();
double P = Math.Abs(GetPrestressForceAtTransfer());
double A = this.Section.SliceableShape.A;
double Sb = this.Section.SliceableShape.S_xBot;
double St = this.Section.SliceableShape.S_xTop;
double Mcomp = 0;
double Mtens = 0;
double fct = GetAllowableTension(Stage);
double fcc = GetAllowableCompression(Stage, LoadType);
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
Mcomp = (fcc - P / A - (P * e) / St) * St;
Mtens = (fct + P / A - (P * e) / Sb) * Sb;
break;
case FlexuralCompressionFiberPosition.Bottom:
Mcomp = (fcc - P / A + (P * e) / Sb) * Sb;
Mtens = (fct + P / A + (P * e) / St) * St;
break;
default:
throw new CompressionFiberPositionException();
}
return(Math.Min(Mcomp, Mtens));
}
internal double GetCriticalStressFcr(FlexuralCompressionFiberPosition compressionFiberLocation)
{
double Fcr;
Fy = this.Section.Material.YieldStress;
double lambdaStem = GetLambdaStem();
if (lambdaStem > 0.84 * SqrtE_Fy())
{
if (lambdaStem<1.03*SqrtE_Fy())
{
//(F9-10)
Fcr = (2.55 - 1.84 * lambdaStem * Math.Sqrt(Fy / E)) * Fy;
}
else
{
//(F9-11)
Fcr = 0.69 * E / Math.Pow(lambdaStem, 2);
}
}
else
{
Fcr = Fy; //(F9-9)
}
return Fcr;
}
public double GetWebPlastificationFactorForTensionRpt(FlexuralCompressionFiberPosition compressionFiberPosition)
{
double Rpt = 0.0;
double Mp = GetMajorNominalPlasticMoment();
double Myt = GetTensionFiberYieldMomentMyt(compressionFiberPosition);
double hc = Gethc(compressionFiberPosition);
double tw = this.Gettw();
ShapeCompactness.IShapeMember compactness = new ShapeCompactness.IShapeMember(Section, IsRolledMember, compressionFiberPosition);
double lambdaWeb = compactness.GetWebLambda();
double lambdapw = compactness.GetWebLambda_p(StressType.Flexure);
double lambdarw = compactness.GetWebLambda_r(StressType.Flexure);
//double lambda = hc / tw;
double lambda = compactness.GetWebLambda();
if (lambda <= lambdapw)
{
Rpt = Mp / Myt; //(F4-16a)
}
else
{
Rpt = Mp / Myt - (Mp / Myt - 1) * ((lambda - lambdapw) / (lambdarw - lambdapw)); //(F4-16b)
}
return Rpt;
}
public double GetEffectiveRadiusOfGyration_r_t( FlexuralCompressionFiberPosition compressionFiberPosition)
{
//todo: add alternative calc
// For I-shapes with a channel cap or a cover plate attached to the compression flange are not covered
double rt = 0.0;
double ho = 0.0;
double bfc = 0.0;
double tfc = 0.0;
double h = 0.0;
double hc = 0.0;
double aw = 0.0;
double tw = 0.0;
double d = 0;
ho = this.GetFlangeCentroidDistanceho();
bfc = this.GetCompressionFlangeWidthbfc(compressionFiberPosition);
h = SectionI.h_web;
hc = Gethc(compressionFiberPosition);
tfc = GetCompressionFlangeThicknesstfc(compressionFiberPosition);
tw = this.Gettw();
aw = Getaw(hc, tw, bfc, tfc);
d = this.GetHeight();//confirm ....
rt = bfc / (Math.Sqrt(12.0 * (ho / d + 1 / 6.0 * aw * Math.Pow(h, 2) / (ho * d)))); //(F4-11)
return rt;
}
private double GetYieldingMomentGeometricXCapacity(FlexuralCompressionFiberPosition compressionFiberLocation, FlexuralAndTorsionalBracingType BracingType)
{
double S_x = GetSectionModulus(compressionFiberLocation, false, BracingType);
double Fy = Section.Material.YieldStress;
double My = S_x * Fy;
return My;
}
private double GetFlexuralTorsionalBucklingMomentCapacity(double L_b, double C_b,
FlexuralCompressionFiberPosition CompressionLocation, FlexuralAndTorsionalBracingType BracingType, MomentAxis MomentAxis)
{
double M_n = 0.0;
double M_n1 = 0.0;
double M_n2 = 0.0;
double M_e = GetM_e(L_b, C_b, CompressionLocation, BracingType, MomentAxis);
double M_y = GetYieldingMomentGeometricXCapacity(CompressionLocation, BracingType);
if (M_e<=M_y)
{
//F10-2
M_n1=(0.92-((0.17*M_e) / (M_y)))*M_e;
}
else
{
//F10-3
M_n1=(1.92-1.17*Math.Sqrt(((M_y) / (M_e))))*M_y;
}
M_n2 = 1.5*M_y;
M_n= Math.Min(M_n1,M_n2);
double phiM_n = 0.9 * M_n;
return phiM_n;
}
public BeamRectangularHss(ISteelSection section, FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis, ICalcLog CalcLog)
: base(section, CalcLog)
{
GetSectionValues();
this.MomentAxis = MomentAxis;
FlangeCompactnessClass = GetFlangeCompactness(compressionFiberPosition, MomentAxis);
}
public IStrainCompatibilityAnalysisResult GetNominalMomentResult(double P_u,
FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double MaxSteelStrain = CalculateMaximumSteelStrain(CompressionFiberPosition);
SectionAnalysisResult IteratedResult = FindMomentResultInPresenceOfAxialForce(CompressionFiberPosition, P_u, MaxSteelStrain);
IStrainCompatibilityAnalysisResult result = GetResult(IteratedResult);
return result;
}
public WebOfSinglySymI(ISteelMaterial Material, ISectionI SectionI,
FlexuralCompressionFiberPosition compressionFiberPosition)
:base(Material,SectionI)
{
this.SectionI = SectionI;
this.compressionFiberPosition = compressionFiberPosition;
}
private double GetYieldingMoment_My(FlexuralCompressionFiberPosition compressionFiberLocation)
{
double Sxt = GetSectionModulusTensionSxt(compressionFiberLocation);
double Sxc = GetSectionModulusCompressionSxc(compressionFiberLocation);
double Sx = Math.Min(Sxc, Sxt);
double Fy = Section.Material.YieldStress;
double My = Sx * Fy;
return My;
}
// Compression Flange Yielding F4.1
public double GetCompressionFlangeYieldingCapacity(FlexuralCompressionFiberPosition compressionFiberPosition)
{
double Mn = 0.0;
double Myc = GetCompressionFiberYieldMomentMyc(compressionFiberPosition);
double Rpc = GetRpc(compressionFiberPosition);
Mn = Rpc * Myc; //(F4-1)
double phiM_n = 0.9 * Mn;
return phiM_n;
}
public override SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
{
if (SectionValuesWereCalculated == false)
{
GetSectionValues();
}
double M_n= GetMajorNominalPlasticMoment();
double phiM_n = 0.9 * M_n;
return new SteelLimitStateValue(phiM_n, true);
}
private double FindCrackedSectionNeutralAxis(FlexuralCompressionFiberPosition compFiberPosition)
{
double targetDelta = 0.0;
double CompressedBlockMin = 0.0;
double CompressedBlockMax = this.Section.SliceableShape.YMax - this.Section.SliceableShape.YMin;
currentCompressionFiberPosition = compFiberPosition; //store this off because it will be necessary during iteration
double ConvergenceTolerance = 0.0001;
double kd = RootFinding.Brent(new FunctionOfOneVariable(DeltaA_times_Y), CompressedBlockMin, CompressedBlockMax, ConvergenceTolerance, targetDelta);
return kd;
}
// Compression Flange Yielding F5.1
public double GetCompressionFlangeYieldingCapacity(FlexuralCompressionFiberPosition compressionFiberPosition)
{
double Mn = 0.0;
double Sxc = compressionFiberPosition == FlexuralCompressionFiberPosition.Top ? Sxtop : Sxbot;
Rpg = GetRpg(compressionFiberPosition);
Mn = Rpg * Sxc*Fy; //(F5-1)
double phiM_n = 0.9 * Mn;
return phiM_n;
}
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 ConcreteFlexuralStrengthResult GetDesignFlexuralStrength(FlexuralCompressionFiberPosition FlexuralCompressionFiberPosition,
ConfinementReinforcementType ConfinementReinforcementType)
{
IStrainCompatibilityAnalysisResult nominalResult = this.GetNominalFlexuralCapacity(FlexuralCompressionFiberPosition);
ConcreteFlexuralStrengthResult result = new ConcreteFlexuralStrengthResult(nominalResult, FlexuralCompressionFiberPosition, this.Section.Material.beta1);
StrengthReductionFactorFactory f = new StrengthReductionFactorFactory();
FlexuralFailureModeClassification failureMode = f.GetFlexuralFailureMode(result.epsilon_t, result.epsilon_ty);
double phi = f.Get_phiFlexureAndAxial(failureMode, ConfinementReinforcementType, result.epsilon_t, result.epsilon_ty);
double phiM_n = phi * nominalResult.Moment;
result.phiM_n = phiM_n; result.FlexuralFailureModeClassification = failureMode;
return result;
}
internal double GetCompressionFiberYieldMomentMyc(FlexuralCompressionFiberPosition compressionFiberPosition)
{
double Myc = 0.0;
double Sxc = 0.0;
double Fy = Section.Material.YieldStress;
Sxc = GetSectionModulusCompressionSxc( compressionFiberPosition);
Myc = Fy * Sxc;
return Myc;
}
//ICompactnessElement FlangeCompactness;
//ICompactnessElement WebCompactness;
public HollowMember(ISteelSection section,
FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis)
{
ISection Section = section.Shape;
if (Section is ISectionTube|| Section is ISectionPipe || Section is ISectionBox)
{
if (Section is ISectionTube)
{
ISectionTube tube = Section as ISectionTube;
if (MomentAxis == MomentAxis.XAxis)
{
FlangeCompactness = new FlangeOfRhs(section.Material, tube, MomentAxis);
WebCompactness = new WebOfRhs(section.Material, tube, MomentAxis);
}
else
{
WebCompactness = new FlangeOfRhs(section.Material, tube, MomentAxis);
FlangeCompactness = new WebOfRhs(section.Material, tube, MomentAxis);
}
}
if (Section is ISectionPipe)
{
ISectionPipe pipe = Section as ISectionPipe;
FlangeCompactness = new WallOfChs(section.Material, pipe);
WebCompactness = new WallOfChs(section.Material, pipe);
}
if (Section is ISectionBox)
{
ISectionBox box = Section as ISectionBox;
if (MomentAxis == MomentAxis.XAxis)
{
FlangeCompactness = new FlangeOfBox(section.Material, box);
WebCompactness = new WebOfBox(section.Material, box);
}
else
{
WebCompactness = new FlangeOfBox(section.Material, box);
FlangeCompactness = new WebOfBox(section.Material, box);
}
}
}
else
{
throw new SectionWrongTypeException("ISectionTube, ISectionPipe or ISectionBox");
}
}
public double GetCrackingMoment( FlexuralCompressionFiberPosition compFiberPosition)
{
double f_r = this.Section.Material.ModulusOfRupture;
//24.2.3.5b
if (compFiberPosition == FlexuralCompressionFiberPosition.Top)
{
return this.Section.SliceableShape.S_xBot * f_r;
}
else
{
return Section.SliceableShape.S_xTop * f_r;
}
}
