//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 SinglySymmetricIBeam(ISteelSection section, bool IsRolledMember, FlexuralCompressionFiberPosition compressionFiberPosition, ICalcLog CalcLog)
{
this.section = section;
this.IsRolledMember = IsRolledMember;
this.CalcLog = CalcLog;
this.compressionFiberPosition = compressionFiberPosition;
}
public BoltBase(double Diameter, BoltThreadCase ThreadType,
ICalcLog log)
: base(log)
{
this.diameter = Diameter;
this.threadType = ThreadType;
}
//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 BuildingDirectionalProcedureElement(double Width, double Length, double Height, double WindSpeed, WindExposureCategory windExposureType,
WindEnclosureType EnclosureClass,
WindStructureDynamicResponseType StructureDynamicClass, double Damping, ICalcLog CalcLog)
: base(Width, Length, Height, WindSpeed, windExposureType, EnclosureClass, StructureDynamicClass, Damping, CalcLog)
{
}
public WindLocation(ICalcLog CalcLog, double Latitude, double Longitude, string County = null)
: base(CalcLog)
{
this.Latitude = Latitude;
this.Longitude = Longitude;
this.County = County;
}
public ChsTransversePlate(SteelChsSection Hss, SteelPlateSection Plate, ICalcLog CalcLog, bool IsTensionHss,
double P_uHss, double M_uHss)
: base(Hss, Plate, CalcLog, IsTensionHss, P_uHss, M_uHss)
{
//assume 90 degrees for plate angle
Angle = 90.0;
}
public ConcreteMaterial(double SpecifiedConcreteStrength,
ConcreteTypeByWeight ConcreteType, TypeOfLightweightConcrete LightWeightConcreteType, ICalcLog log)
: base(SpecifiedConcreteStrength, ConcreteType, log)
{
this.LightWeightConcreteType = LightWeightConcreteType;
}
public BeamSimple(double Length, LoadBeam Loads, ICalcLog CalcLog)
: base(Length, Loads, CalcLog, new BeamSimpleFactory())
{
//LoadCases = new List<ISingleLoadCaseBeam>();
}
public AciConcreteShearTestsBase()
{
//ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
MockRepository mocks = new MockRepository();
log = mocks.Stub<ICalcLog>();
tolerance = 0.02; //2% can differ from rounding
}
public ChsTransversePlate(SteelChsSection Hss, SteelPlateSection Plate, ICalcLog CalcLog, bool IsTensionHss,
double P_uHss, double M_uHss)
: base(Hss, Plate, CalcLog, IsTensionHss, P_uHss, M_uHss)
{
//assume 90 degrees for plate angle
Angle = 90.0;
}
public WindLocation(ICalcLog CalcLog, double Latitude, double Longitude, string County=null)
: base(CalcLog)
{
this.Latitude = Latitude;
this.Longitude = Longitude;
this.County = County;
}
public ISteelCompressionMember GetIshape(ISteelSection Section, bool IsRolled, double L_x, double L_y, double L_z, ICalcLog CalcLog)
{
ISteelCompressionMember column = null;
IShapeCompactness compactnessTop = new ShapeCompactness.IShapeMember(Section, IsRolled, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Top);
IShapeCompactness compactnessBot = new ShapeCompactness.IShapeMember(Section, IsRolled, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Bottom);
ICalcLog Log = new CalcLog();
CompactnessClassAxialCompression flangeCompactnessTop = compactnessTop.GetFlangeCompactnessCompression();
CompactnessClassAxialCompression flangeCompactnessBot = compactnessTop.GetFlangeCompactnessCompression();
CompactnessClassAxialCompression webCompactness = compactnessTop.GetWebCompactnessCompression();
if (flangeCompactnessTop == CompactnessClassAxialCompression.NonSlender && webCompactness == CompactnessClassAxialCompression.NonSlender
&& flangeCompactnessBot == CompactnessClassAxialCompression.NonSlender)
{
column = new IShapeCompact(Section, IsRolled, L_x, L_y, L_z, Log);
//if (IShape.b_fBot == IShape.b_fTop && IShape.t_fBot == IShape.t_fTop)
//{
// return new IShapeCompact(SectionI, IsRolledShape, L_ex, L_ey, L_ez, log);
//}
//else
//{
// throw new NotImplementedException();
//}
}
else
{
column = new IShapeSlenderElements(Section, IsRolled, L_x, L_y, L_z, Log);
}
return column;
}
public IAnalysisBeam CreateBeamInstance(string BeamCaseId, LoadBeam load, ICalcLog Log)
{
double L = d.L;
double LoadDimension_a = d.a_load;
Beam bm = null;
if (BeamCaseId.StartsWith("C1") == true)
{
bm = new BeamSimple(d.L, load, Log);
}
else if (BeamCaseId.StartsWith("C2") == true)
{
bm = new BeamSimpleWithOverhang(L, LoadDimension_a, load, Log);
}
else if (BeamCaseId.StartsWith("C3") == true)
{
bm = new BeamPinnedFixed(L, load, Log);
}
else if (BeamCaseId.StartsWith("C4") == true)
{
bm = new BeamFixedFixed(L, load, Log);
}
else //else if (BeamCaseId.StartsWith("C5") == true)
{
bm = new BeamCantilever(L, load, Log);
}
bm.ModulusOfElasticity = d.E;
bm.MomentOfInertia = d.I;
return(bm);
}
//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 DoublySymmetricIBeam(ISteelSection section, ICalcLog CalcLog, FlexuralCompressionFiberPosition compressionFiberPosition, bool IsRolledMember)
{
this.section = section;
this.IsRolledMember = IsRolledMember;
this.CalcLog = CalcLog;
this.compressionFiberPosition = compressionFiberPosition;
}
public IAnalysisBeam CreateBeamInstance(string BeamCaseId, LoadBeam load, ICalcLog Log)
{
double L = d.L;
double LoadDimension_a = d.a_load;
Beam bm = null;
if (BeamCaseId.StartsWith("C1") == true)
{
bm = new BeamSimple(d.L, load, Log);
}
else if (BeamCaseId.StartsWith("C2") == true)
{
bm = new BeamSimpleWithOverhang(L, LoadDimension_a, load, Log);
}
else if (BeamCaseId.StartsWith("C3") == true)
{
bm = new BeamPinnedFixed(L,load, Log);
}
else if (BeamCaseId.StartsWith("C4") == true)
{
bm = new BeamFixedFixed(L, load, Log);
}
else //else if (BeamCaseId.StartsWith("C5") == true)
{
bm = new BeamCantilever(L, load, Log);
}
bm.ModulusOfElasticity = d.E;
bm.MomentOfInertia = d.I;
return bm;
}
public BeamSimpleWithOverhang(double Length, double OverhangLength, LoadBeam load, ICalcLog CalcLog)
: base(Length, load, CalcLog, new BeamSimpleWithOverhangFactory())
{
this.OverhangLength = OverhangLength;
TotalLength = Length + OverhangLength;
}
public HssToPlateConnection(bool IsTensionMember,
double P_uHss, double M_uHss, ICalcLog CalcLog)
{
this.IsTensionHss = IsTensionMember;
this.P_uHss = P_uHss;
this.M_uHss = M_uHss;
}
//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 HssToPlateConnection(bool IsTensionMember,
double P_uHss, double M_uHss, ICalcLog CalcLog)
{
this.IsTensionHss = IsTensionMember;
this.P_uHss = P_uHss;
this.M_uHss = M_uHss;
}
public AciFlexureRectangularBeamTests()
{
//ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
MockRepository mocks = new MockRepository();
log = mocks.Stub<ICalcLog>();
tolerance = 0.02; //2% can differ from rounding
}
public WoodSolidMaterial( string Species, string CommercialGrade, string SizeClass, ICalcLog CalcLog)
: base(CalcLog)
{
this.Species = Species;
this.CommercialGrade = CommercialGrade;
this.SizeClass = SizeClass;
}
private StandardHookInTension CreateHookObject(double ConcStrength, double RebarDiameter, bool IsEpoxyCoated,
ConcreteTypeByWeight typeByWeight, double ExcessFlexureReinforcementRatio)
{
MockRepository mocks = new MockRepository();
IRebarMaterial rebarMat = mocks.Stub <IRebarMaterial>();
Expect.Call(rebarMat.YieldStress).Return(60000);
Rebar rebar = new Rebar(RebarDiameter, IsEpoxyCoated, rebarMat);
ICalcLogEntry entryStub = mocks.Stub <ICalcLogEntry>();
ICalcLog logStub = mocks.Stub <ICalcLog>();
//IConcreteMaterial ConcStub = mocks.Stub<IConcreteMaterial>();
IConcreteMaterial ConcStub = new ConcreteMaterial(ConcStrength, typeByWeight, logStub) as IConcreteMaterial;
ConcStub.SpecifiedCompressiveStrength = ConcStrength;
ConcStub.TypeByWeight = typeByWeight;
using (mocks.Record())
{
logStub.CreateNewEntry();
LastCall.Return(entryStub);
}
StandardHookInTension tensHook = new StandardHookInTension(ConcStub, rebar, logStub, ExcessFlexureReinforcementRatio);
return(tensHook);
}
public ConcreteMaterialBase(double SpecifiedConcreteStrength,
ConcreteTypeByWeight ConcreteType, double Density, ICalcLog log): base(log)
{
this.fc = SpecifiedConcreteStrength;
this.typeByWeight = ConcreteType;
this.wc = Density;
}
public WindStructure(double Width, double Length, double Height, double WindSpeed,
WindStructureDynamicResponseType StructureDynamicClass,
double Damping, ICalcLog CalcLog)
: this(Width, Length, Height, WindSpeed, WindExposureCategory.C, WindEnclosureType.Enclosed, StructureDynamicClass, Damping, CalcLog)
{
terrainCoefficientsNeedCalculation = true;
}
public AciFlexureRectangularBeamTests()
{
//ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
MockRepository mocks = new MockRepository();
log = mocks.Stub <ICalcLog>();
tolerance = 0.02; //2% can differ from rounding
}
public BoltBearingThreadedGeneral(double Diameter, BoltThreadCase ThreadType, IBoltMaterial material,
ICalcLog log = null)
: base(Diameter, ThreadType, log)
{
this.material = material;
nominalTensileStress = material.GetNominalTensileStress(ThreadType);
nominalShearStress = material.GetNominalShearStress(ThreadType);
}
public BeamRectangularHss(ISteelSection section, FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis, ICalcLog CalcLog)
: base(section, CalcLog)
{
GetSectionValues();
this.MomentAxis = MomentAxis;
FlangeCompactnessClass = GetFlangeCompactness(compressionFiberPosition, MomentAxis);
}
public AffectedElementInFlexure(SectionRectangular Section, ISteelMaterial Material, ICalcLog CalcLog, bool IsRolled=false)
: base(Section, Material, CalcLog)
{
this.HasHolesInTensionFlange = false;
this.A_fg = 0;
this.A_fn = 0;
this.IsRolled = IsRolled;
}
public AciConcreteShearTestsBase()
{
//ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
MockRepository mocks = new MockRepository();
log = mocks.Stub <ICalcLog>();
tolerance = 0.02; //2% can differ from rounding
}
public SeismicLocation(double Latitude, double Longitude, List<MapDataInfo> LoadedMapsInfo, ICalcLog Log)
:base(Log)
{
this.Latitude = Latitude;
this.Longitude = Longitude;
this.LoadedMapsInfo = LoadedMapsInfo;
IsDirty = true;
}
public BoltBearingGroupB(double Diameter, BoltThreadCase ThreadType,
ICalcLog log = null)
: base(Diameter, ThreadType, log)
{
material = new BoltGroupBMaterial();
nominalTensileStress = material.GetNominalTensileStress(ThreadType);
nominalShearStress = material.GetNominalShearStress(ThreadType);
}
public Beam(double Length, LoadBeam Load, ICalcLog CalcLog, IBeamCaseFactory BeamCaseFactory)
: base(CalcLog)
{
this.length = Length;
hasCalculatedForces = false;
hasCalculatedDeflections = false;
this.BeamCaseFactory = BeamCaseFactory;
this.Load = Load;
}
public Weld(double F_y, double F_u, double F_EXX, double Size, double A_nBase, double l, ICalcLog Log)
: base( Log)
{
this.WeldMaterial = new WeldMaterial(F_EXX);
this.BaseMaterial = new SteelMaterial(F_y, F_u, 0.0, 0.0);
this.A_nBase = A_nBase;
this.Size = Size;
this.Length = l;
}
public Beam(double Length, LoadBeam Load, ICalcLog CalcLog, IBeamCaseFactory BeamCaseFactory)
: base(CalcLog)
{
this.length = Length;
hasCalculatedForces = false;
hasCalculatedDeflections = false;
this.BeamCaseFactory = BeamCaseFactory;
this.Load = Load;
}
public WoodColumn(double Emin, double CM, double Ct, double CT, double Ci, double Cr, ICalcLog CalcLog): base(CalcLog)
{
this.Emin=Emin;
this.CM= CM;
this.Ct= Ct;
this.CT= CT;
this.Ci= Ci;
this.Cr= Cr;
}
public PrestressedConcreteSection(IPrestressedConcreteSection Section, List<RebarPoint> LongitudinalBars,
CrossSectionLocationType LocationType, MemberClass MemberClass, ICalcLog log)
: base(Section,LongitudinalBars, log)
{
this.crossSectionLocationType = LocationType;
this.memberClass = MemberClass;
this.prestressedSection = Section;
}
public BoltBearingThreadedGeneral(double Diameter, BoltThreadCase ThreadType, IBoltMaterial material,
ICalcLog log=null)
: base(Diameter, ThreadType, log)
{
this.material = material;
nominalTensileStress = material.GetNominalTensileStress(ThreadType);
nominalShearStress = material.GetNominalShearStress(ThreadType);
}
public BuildingLateralSystem(string SystemId, SeismicDesignCategory Sdc, ICalcLog CalcLog)
: base(CalcLog)
{
this.SeismicLateralSystemId = SystemId;
this.SeismicDesignCategory = Sdc;
if (SystemId != null)
{
this.ReadTableData();
}
}
public BoltSlipCriticalGroupA(double Diameter, BoltThreadCase ThreadType,
BoltFayingSurfaceClass FayingSurface, BoltHoleType HoleType,
BoltFillerCase Fillers, int NumberOfSlipPlanes, ICalcLog log, double PretensionMultiplier = 1.13):
base(Diameter,ThreadType,FayingSurface,HoleType,Fillers,NumberOfSlipPlanes,log,PretensionMultiplier)
{
material = new BoltGroupAMaterial();
nominalTensileStress = material.GetNominalTensileStress(ThreadType);
nominalShearStress = material.GetNominalTensileStress(ThreadType);
}
public BoltBearingGroupB(double Diameter, BoltThreadCase ThreadType,
ICalcLog log=null)
:base(Diameter,ThreadType,log)
{
material = new BoltGroupBMaterial();
nominalTensileStress = material.GetNominalTensileStress(ThreadType);
nominalShearStress = material.GetNominalShearStress(ThreadType);
}
public BeamAngle(ISteelSection section, ICalcLog CalcLog, AngleRotation AngleRotation, MomentAxis MomentAxis,
AngleOrientation AngleOrientation = AngleOrientation.ShortLegVertical)
: base(section, CalcLog, AngleOrientation)
{
this.AngleRotation = AngleRotation;
this.AngleOrientation = AngleOrientation;
this.MomentAxis = MomentAxis;
GetSectionValues();
}
public ConcreteSectionCompression GetRectangularCompressionMember(double Width, double Height, IConcreteMaterial ConcreteMaterial,
List <RebarPoint> LongitudinalBars, ConfinementReinforcementType ConfinementReinforcement,
ICalcLog log, bool IsPrestressed = false)
{
CrossSectionRectangularShape Section = new CrossSectionRectangularShape(ConcreteMaterial, null, Width, Height);
CompressionMemberType CompressionMemberType = GetCompressionMemberType(ConfinementReinforcement, IsPrestressed);
ConcreteSectionCompression column = new ConcreteSectionCompression(Section, LongitudinalBars, CompressionMemberType, log);
return(column);
}
public ConcreteMaterialBase(double SpecifiedConcreteStrength,
ConcreteTypeByWeight ConcreteType, double Density, double AverageSplittingTensileStrength,
ICalcLog log)
: base(log)
{
this.fc = SpecifiedCompressiveStrength;
this.typeByWeight = ConcreteType;
this.wc = Density;
this.averageSplittingTensileStrength = AverageSplittingTensileStrength;
}
public BuildingLateralSystem(string SystemId, SeismicDesignCategory Sdc, ICalcLog CalcLog)
: base(CalcLog)
{
this.SeismicLateralSystemId = SystemId;
this.SeismicDesignCategory = Sdc;
if (SystemId!=null)
{
this.ReadTableData();
}
}
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 ConcreteMaterialBase(double SpecifiedConcreteStrength,
ConcreteTypeByWeight ConcreteType, double Density, double AverageSplittingTensileStrength,
ICalcLog log)
: base(log)
{
this.fc = SpecifiedCompressiveStrength;
this.typeByWeight = ConcreteType;
this.wc = Density;
this.averageSplittingTensileStrength = AverageSplittingTensileStrength;
}
public BoltSlipCritical(double Diameter, BoltThreadCase ThreadType,
BoltFayingSurfaceClass FayingSurface, BoltHoleType HoleType,
BoltFillerCase Fillers, int NumberOfSlipPlanes, ICalcLog log, double PretensionMultiplier=1.13)
: base(Diameter, ThreadType, log)
{
this.fayingSurface = FayingSurface;
this.holeType = HoleType;
this.fillers = Fillers;
this.pretensionMultiplier = PretensionMultiplier;
this.numberOfSlipPlanes = NumberOfSlipPlanes;
}
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 BoltSlipCritical(double Diameter, BoltThreadCase ThreadType,
BoltFayingSurfaceClass FayingSurface, BoltHoleType HoleType,
BoltFillerCase Fillers, int NumberOfSlipPlanes, ICalcLog log, double PretensionMultiplier = 1.13)
: base(Diameter, ThreadType, log)
{
this.fayingSurface = FayingSurface;
this.holeType = HoleType;
this.fillers = Fillers;
this.pretensionMultiplier = PretensionMultiplier;
this.numberOfSlipPlanes = NumberOfSlipPlanes;
}
public double GetMinimumTransverseReinforcement(IConcreteSection Section,
double f_yt, double s, ICalcLog log)
{
double f_c = Section.Material.SpecifiedCompressiveStrength;
double b_w = Section.b_w;
//Table 9.6.3.3—Required Av,min
double A_vMin1 = 0.75 * Section.Material.Sqrt_f_c_prime * ((b_w) / (f_yt)) * s;
double A_vMin2 = 50 * ((b_w) / (f_yt)) * s;
return(Math.Max(A_vMin1, A_vMin2));
}
public TensionLapSplice(
double rebar1Diameter, double rebar1DevelopmentLength,
double rebar2Diameter, double rebar2DevelopmentLength,
TensionLapSpliceClass SpliceClass,
ICalcLog log) : base(log)
{
this.spliceClass = SpliceClass;
this.Rebar1Diameter = rebar1Diameter;
this.Rebar2Diameter = rebar2Diameter;
this.Rebar1DevelopmentLength = Rebar1DevelopmentLength;
this.Rebar2DevelopmentLength = Rebar2DevelopmentLength;
}
public AiscCatalogShape(string ShapeName, ICalcLog CalcLog)
: base(ShapeName)
{
if (ShapeName != null)
{
bool shapeFound = ReadShapePropertiesInCatalog(ShapeName);
if (shapeFound == false)
{
throw new Exception("Shape name not found in AISC shape database.");
}
}
}
public RhsSlender(ISteelSection Section, double L_x, double L_y, double L_z, ICalcLog CalcLog)
: base(Section, L_x, L_y, L_z, CalcLog)
{
if (Section.Shape is ISectionTube)
{
SectionRhs = Section.Shape as ISectionTube;
}
else
{
throw new Exception("Section of wrong type: Need ISectionTube");
}
}
public BeamTee(ISteelSection section, ICalcLog CalcLog)
: base(section, CalcLog)
{
if (section is ISectionTee)
{
SectionTee = section as ISectionTee;
}
else
{
throw new SectionWrongTypeException(typeof(ISectionTee));
}
GetSectionValues();
}
public BeamSolid(ISteelSection section, ICalcLog CalcLog, MomentAxis MomentAxis) :
base(section, CalcLog)
{
this.MomentAxis = MomentAxis;
GetSectionValues();
sectionSolid = null;
ISolidShape s = Section.Shape as ISolidShape;
if (s == null)
{
throw new SectionWrongTypeException(typeof(ISolidShape));
}
}
public AnalyticalElement(ICalcLog CalcLog)
{
if (CalcLog == null)
{
this.log = new CalcLog(new List <CalcLogEntry>());
LogModeActive = true;
}
else
{
this.log = CalcLog;
LogModeActive = true;
}
}
public BeamCircularHss(ISteelSection section, ICalcLog CalcLog)
: base(section, CalcLog)
{
if (section is ISectionPipe)
{
SectionPipe = section as ISectionPipe;
}
else
{
throw new SectionWrongTypeException(typeof(ISectionTube));
}
GetSectionValues();
}
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;
}
