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;
        }

        //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 WindLocation(ICalcLog CalcLog, double Latitude, double Longitude, string County=null)
     : base(CalcLog)
 {
     this.Latitude = Latitude;
     this.Longitude = Longitude;
     this.County = County;
 }

        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;
     }

 public ConcreteMaterialBase(double SpecifiedConcreteStrength,
     ConcreteTypeByWeight ConcreteType, double Density, ICalcLog log): base(log)
 {
     this.fc = SpecifiedConcreteStrength;
     this.typeByWeight = ConcreteType;
     this.wc = Density;
 }

 public SinglySymmetricIBeam(ISteelSection section, bool IsRolledMember, FlexuralCompressionFiberPosition compressionFiberPosition, ICalcLog CalcLog)
 {
     this.section = section;
     this.IsRolledMember = IsRolledMember;
     this.CalcLog = CalcLog;
     this.compressionFiberPosition = compressionFiberPosition;
 }

        public BeamSimple(double Length, LoadBeam Loads, ICalcLog CalcLog)
            : base(Length, Loads, CalcLog, new BeamSimpleFactory())
        {

            //LoadCases = new List<ISingleLoadCaseBeam>();

        }

 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 WoodSolidMaterial( string Species, string CommercialGrade, string SizeClass, ICalcLog CalcLog)
     : base(CalcLog)
 {
     this.Species = Species;
     this.CommercialGrade = CommercialGrade;
     this.SizeClass = SizeClass;
 }

 public AciConcreteShearTestsBase()
 {
     //ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
     MockRepository mocks = new MockRepository();
     log = mocks.Stub<ICalcLog>();
     tolerance = 0.02; //2% can differ from rounding
 }

		public ConcreteMaterial(double SpecifiedConcreteStrength,
		ConcreteTypeByWeight ConcreteType, TypeOfLightweightConcrete LightWeightConcreteType, ICalcLog log)
			: base(SpecifiedConcreteStrength, ConcreteType, log)
		{
			this.LightWeightConcreteType = LightWeightConcreteType;

		}

 public AciFlexureRectangularBeamTests()
 {
     //ICalcLogEntry entryStub = mocks.Stub<ICalcLogEntry>();
     MockRepository mocks = new MockRepository();
     log = mocks.Stub<ICalcLog>();
     tolerance = 0.02; //2% can differ from rounding
 }

 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 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 SeismicLocation(double Latitude, double Longitude, List<MapDataInfo> LoadedMapsInfo, ICalcLog Log)
     :base(Log)
 {
     this.Latitude = Latitude;
     this.Longitude = Longitude;
     this.LoadedMapsInfo = LoadedMapsInfo;
     IsDirty = true;
 }

        public BeamRectangularHss(ISteelSection section, FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis, ICalcLog CalcLog)
            : base(section, CalcLog)
        {
            GetSectionValues();
            this.MomentAxis = MomentAxis;
            FlangeCompactnessClass = GetFlangeCompactness(compressionFiberPosition, MomentAxis);

        }

        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 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;
 }