private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadConcentratedGeneral) //1B.1
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadBetweenSupports b = new ConcentratedLoadBetweenSupports(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
else if (load is LoadConcentratedSpecial)
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
if (cl.Case == LoadConcentratedSpecialCase.CantileverTip)
{
ConcentratedLoadOverhang b = new ConcentratedLoadOverhang(beam, cl.P, beam.OverhangLength);
beamForceCase = b;
beamDeflectionCase = b;
}
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
BeamCase beamCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
UniformlyDistributedLoad b = new UniformlyDistributedLoad(beam, cl.Value); //4B.1
beamForceCase = b;
beamDeflectionCase = b;
return new BeamCase(beamForceCase, beamDeflectionCase);
}
if (load is LoadDistributedGeneral) //4C.1
{
LoadDistributedGeneral cl = load as LoadDistributedGeneral;
UniformPartialLoad b = new UniformPartialLoad(beam, cl.Value, cl.XLocationStart,
cl.XLocationEnd - cl.XLocationStart);
beamForceCase = b;
beamDeflectionCase = null;
return new BeamCase(beamForceCase, beamDeflectionCase);
}
return beamCase;
}
private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadConcentratedGeneral) //1B.1
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadBetweenSupports b = new ConcentratedLoadBetweenSupports(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
else if (load is LoadConcentratedSpecial)
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
if (cl.Case == LoadConcentratedSpecialCase.CantileverTip)
{
ConcentratedLoadOverhang b = new ConcentratedLoadOverhang(beam, cl.P, beam.OverhangLength);
beamForceCase = b;
beamDeflectionCase = b;
}
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
BeamCase beamCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
UniformlyDistributedLoad b = new UniformlyDistributedLoad(beam, cl.Value); //4B.1
beamForceCase = b;
beamDeflectionCase = b;
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
if (load is LoadDistributedGeneral) //4C.1
{
LoadDistributedGeneral cl = load as LoadDistributedGeneral;
UniformPartialLoad b = new UniformPartialLoad(beam, cl.Value, cl.XLocationStart,
cl.XLocationEnd - cl.XLocationStart);
beamForceCase = b;
beamDeflectionCase = null;
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
return(beamCase);
}
public BeamSimple(double Length, LoadBeam Loads, ICalcLog CalcLog)
: base(Length, Loads, CalcLog, new BeamSimpleFactory())
{
//LoadCases = new List<ISingleLoadCaseBeam>();
}
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;
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
switch (cl.Case)
{
case LoadDistributedSpecialCase.CantileverOverhang:
DistributedLoadOverhang b1 = new DistributedLoadOverhang(beam, cl.Value); //2C.2
beamForceCase = b1;
beamDeflectionCase = b1;
break;
case LoadDistributedSpecialCase.CantileverMainSpan:
DistributedLoadBetweenSupports b2 = new DistributedLoadBetweenSupports(beam, cl.Value); //2C.1
beamForceCase = b2;
beamDeflectionCase = b2;
break;
default:
UniformLoadFull b3 = new UniformLoadFull(beam, cl.Value); //2B.1
beamForceCase = b3;
beamDeflectionCase = b3;
break;
}
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
public virtual LoadBeam GetBeamLoad(string loadingType, string subCase)
{
LoadBeam Load = null;
switch (loadingType)
{
case "A": //concentrated loads
return(GetConcentratedCase(subCase));
case "B": //distributed loads
return(GetUniformDistributedCase(subCase));
case "C": //partially distributed loads
return(GetPartialDistributedCase(subCase));
case "D": //Varying loads
return(GetVaryingCase(subCase));
case "E": //Moments
return(GetMomentCase(subCase));
default:
break;
}
return(Load);
}
public virtual LoadBeam GetPartialDistributedCase(string subCase)
{
LoadBeam Load = null;
Load = new LoadDistributedGeneral(d.w, d.a_load, d.a_load + d.b_load);
return(Load);
}
public virtual LoadBeam GetConcentratedCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadConcentratedSpecial(d.P);
break;
case "2":
Load = new LoadConcentratedGeneral(d.P, d.a_load);
break;
case "3":
Load = new LoadConcentratedDoubleSymmetrical(d.P, d.a_load);
break;
case "4":
Load = new LoadConcentratedDoubleUnsymmetrical(d.P1, d.P2, d.a_load, d.b_load);
break;
case "5":
Load = new LoadConcentratedCenterWithEndMoments(d.P, d.M1, d.M2);
break;
default:
Load = null;
break;
}
return(Load);
}
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);
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadMomentLeftEnd)//1E.1
{
LoadMomentLeftEnd cl = load as LoadMomentLeftEnd;
MomentAtOneEnd b1 = new MomentAtOneEnd(beam, cl.Mo);
beamForceCase = b1;
beamDeflectionCase = b1;
}
if (load is LoadMomentGeneral)//1E.2
{
LoadMomentGeneral cl = load as LoadMomentGeneral;
MomentAtAnyPoint b2 = new MomentAtAnyPoint(beam, cl.Mo, cl.Location);
beamForceCase = b2;
beamDeflectionCase = null;
}
if (load is LoadMomentBothEnds)//1E.3
{
LoadMomentBothEnds cl = load as LoadMomentBothEnds;
beamForceCase = new MomentAtBothEnds(beam, cl.M1, cl.M2);
beamDeflectionCase = null;
}
if (load is LoadMomentRightEnd)//1E.4
{
LoadMomentRightEnd cl = load as LoadMomentRightEnd;
beamForceCase = new MomentAtFarEnd(beam, cl.Mo);
beamDeflectionCase = null;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
public ISingleLoadCaseDeflectionBeam GetDeflectionCase(LoadBeam load, IAnalysisBeam beam)
{
BeamCase bc = GetCase(load, beam);
if (bc.DeflectionCase == null)
{
throw new Exception(CaseNotSupportedExceptionText);
}
return bc.DeflectionCase;
}
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 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 ISingleLoadCaseDeflectionBeam GetDeflectionCase(LoadBeam load, IAnalysisBeam beam)
{
BeamCase bc = GetCase(load, beam);
if (bc.DeflectionCase == null)
{
throw new Exception(CaseNotSupportedExceptionText);
}
return(bc.DeflectionCase);
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
LoadMomentGeneral cl = load as LoadMomentGeneral; //4E.1
beamForceCase = new MomentAtAnyPoint(beam, cl.Mo, cl.Location);
beamDeflectionCase = null;
return new BeamCase(beamForceCase, beamDeflectionCase);
}
IAnalysisBeam GetBeam(double L, double a, double P)
{
BeamFactoryData dat = new BeamFactoryData(L, P, 0, 0, a, 0, 0, 0, 0, 0, 0, 29000, 510); //W18X35
string BeamCaseId = "C3A_2";
BeamLoadFactoryLocator loc = new BeamLoadFactoryLocator();
IBeamLoadFactory loadFactory = loc.GetLoadFactory(BeamCaseId, dat);
LoadBeam load = loadFactory.GetLoad(BeamCaseId);
BeamInstanceFactory beamFactory = new BeamInstanceFactory(dat);
IAnalysisBeam bm = beamFactory.CreateBeamInstance(BeamCaseId, load, null);
return(bm);
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
LoadMomentGeneral cl = load as LoadMomentGeneral; //4E.1
beamForceCase = new MomentAtAnyPoint(beam, cl.Mo, cl.Location);
beamDeflectionCase = null;
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
LoadMomentLeftEnd cl = load as LoadMomentLeftEnd; //3E.1
MomentAtFreeEnd b = new MomentAtFreeEnd(beam, cl.Mo);
beamForceCase = b;
beamDeflectionCase = b;
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadMomentLeftEnd)//5E.1
{
LoadMomentLeftEnd cl = load as LoadMomentLeftEnd;
MomentAtTip b = new MomentAtTip(beam, cl.Mo);
beamForceCase = b;
beamDeflectionCase = b;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
public BeamCase GetCase(LoadBeam load, IAnalysisBeam beam)
{
this.beam = beam as BeamSimpleWithOverhang;
BeamCase BeamLoadCase = null;
if (load is LoadConcentrated)
{
BeamLoadCase = GetConcentratedLoadCase(load);
}
else if (load is LoadDistributed)
{
BeamLoadCase = GetDistributedLoadCase(load);
}
return(BeamLoadCase);
}
public virtual LoadBeam GetUniformDistributedCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadDistributedUniform(d.w);
break;
case "2":
Load = new LoadDistributedUniformWithEndMoments(d.w, d.M1, d.M2);
break;
}
return(Load);
}
public override LoadBeam GetConcentratedCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadConcentratedSpecial(d.P, LoadConcentratedSpecialCase.CantileverTip);
break;
default:
Load = new LoadConcentratedGeneral(d.P, d.a_load);
break;
}
return(Load);
}
public override LoadBeam GetVaryingCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "2":
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.InvertedTriangle);
break;
default:
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.Triangle);
break;
}
return(Load);
}
public override LoadBeam GetPartialDistributedCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.CantileverMainSpan);
break;
case "2":
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.CantileverOverhang);
break;
}
return(Load);
}
public BeamCase GetCase(LoadBeam load, IAnalysisBeam beam)
{
this.beam = beam as BeamSimpleWithOverhang;
BeamCase BeamLoadCase = null;
if (load is LoadConcentrated)
{
BeamLoadCase = GetConcentratedLoadCase(load);
}
else if (load is LoadDistributed)
{
BeamLoadCase = GetDistributedLoadCase(load);
}
return BeamLoadCase;
}
public virtual LoadBeam GetVaryingCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.Triangle);
break;
case "2":
Load = new LoadDistributedUniform(d.w, LoadDistributedSpecialCase.DoubleTriangle);
break;
}
return(Load);
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
switch (cl.Case)
{
case LoadDistributedSpecialCase.Triangle:
DistributedUniformlyIncreasingToEnd b1 = new DistributedUniformlyIncreasingToEnd(beam, cl.Value); //1D.1
beamForceCase = b1;
beamDeflectionCase = b1;
break;
case LoadDistributedSpecialCase.DoubleTriangle:
DistributedDoubleTriangle b2 = new DistributedDoubleTriangle(beam, cl.Value); //1D.2
beamForceCase = b2;
beamDeflectionCase = b2;
break;
default:
UniformLoad b3 = new UniformLoad(beam, cl.Value); //1B.1
beamForceCase = b3;
beamDeflectionCase = b3;
break;
}
}
if (load is LoadDistributedUniformWithEndMoments) //1B.2
{
LoadDistributedUniformWithEndMoments cl = load as LoadDistributedUniformWithEndMoments;
beamForceCase = new UniformLoadAndEndMoments(beam, cl.Value, cl.M1, cl.M2);
beamDeflectionCase = null;
}
if (load is LoadDistributedGeneral) //1C.1
{
LoadDistributedGeneral cl = load as LoadDistributedGeneral;
beamForceCase = new UniformPartialLoad(beam, cl.Value, cl.XLocationStart, cl.XLocationEnd - cl.XLocationStart);
beamDeflectionCase = null;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadConcentratedSpecial) //1A.1
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
ConcentratedLoadAtCenter b = new ConcentratedLoadAtCenter(beam, cl.P);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedGeneral) //1A.2
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadAtAnyPoint b = new ConcentratedLoadAtAnyPoint(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedDoubleSymmetrical) //1A.3
{
LoadConcentratedDoubleSymmetrical cl = load as LoadConcentratedDoubleSymmetrical;
TwoConcentratedLoadsSymmetrical b =
new TwoConcentratedLoadsSymmetrical(beam, cl.P, cl.Dimension_a);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedDoubleUnsymmetrical) //1A.4
{
LoadConcentratedDoubleUnsymmetrical cl = load as LoadConcentratedDoubleUnsymmetrical;
TwoConcentratedLoadsUnsymmetrical b =
new TwoConcentratedLoadsUnsymmetrical(beam, cl.P1, cl.P2, cl.Dimension_a, cl.Dimension_b);
beamForceCase = b;
beamDeflectionCase = null;
}
if (load is LoadConcentratedCenterWithEndMoments) //1A.5
{
LoadConcentratedCenterWithEndMoments cl = load as LoadConcentratedCenterWithEndMoments;
ConcentratedLoadAtCenterAndVarEndMoments b =
new ConcentratedLoadAtCenterAndVarEndMoments(beam, cl.P, cl.M1, cl.M2);
beamForceCase = b;
beamDeflectionCase = null;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadConcentratedSpecial) //1A.1
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
ConcentratedLoadAtCenter b = new ConcentratedLoadAtCenter(beam, cl.P);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedGeneral) //1A.2
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadAtAnyPoint b=new ConcentratedLoadAtAnyPoint(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedDoubleSymmetrical) //1A.3
{
LoadConcentratedDoubleSymmetrical cl = load as LoadConcentratedDoubleSymmetrical;
TwoConcentratedLoadsSymmetrical b =
new TwoConcentratedLoadsSymmetrical(beam, cl.P, cl.Dimension_a);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedDoubleUnsymmetrical) //1A.4
{
LoadConcentratedDoubleUnsymmetrical cl = load as LoadConcentratedDoubleUnsymmetrical;
TwoConcentratedLoadsUnsymmetrical b =
new TwoConcentratedLoadsUnsymmetrical(beam, cl.P1, cl.P2, cl.Dimension_a, cl.Dimension_b);
beamForceCase = b;
beamDeflectionCase = null;
}
if (load is LoadConcentratedCenterWithEndMoments) //1A.5
{
LoadConcentratedCenterWithEndMoments cl = load as LoadConcentratedCenterWithEndMoments;
ConcentratedLoadAtCenterAndVarEndMoments b =
new ConcentratedLoadAtCenterAndVarEndMoments(beam, cl.P, cl.M1, cl.M2);
beamForceCase = b;
beamDeflectionCase = null;
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadConcentratedSpecial) //3A.1
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
beamDeflectionCase = new ConcentratedLoadAtCenter(beam, cl.P);
}
if (load is LoadConcentratedGeneral) //3A.2
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadAtAnyPoint b = new ConcentratedLoadAtAnyPoint(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
private BeamCase GetCase(LoadBeam load, IAnalysisBeam beam)
{
this.beam = beam as BeamFixedFixed;
BeamCase BeamLoadCase = null;
if (load is LoadConcentrated)
{
BeamLoadCase = GetConcentratedLoadCase(load);
}
else if (load is LoadDistributed)
{
BeamLoadCase = GetDistributedLoadCase(load);
}
else if (load is LoadMoment)
{
BeamLoadCase = GetMomentLoadCase(load);
}
return(BeamLoadCase);
}
private BeamCase GetCase(LoadBeam load, IAnalysisBeam beam)
{
this.beam = beam as BeamFixedFixed;
BeamCase BeamLoadCase = null;
if (load is LoadConcentrated)
{
BeamLoadCase = GetConcentratedLoadCase(load);
}
else if (load is LoadDistributed)
{
BeamLoadCase = GetDistributedLoadCase(load);
}
else if (load is LoadMoment)
{
BeamLoadCase = GetMomentLoadCase(load);
}
return BeamLoadCase;
}
public static Dictionary <string, object> BeamDeflections(string BeamDeflectionCaseId, double L, double P, double M, double w, double E, double I, double a_load = 0, double b_load = 0, double c_load = 0, double P1 = 0, double P2 = 0, double M1 = 0, double M2 = 0)
{
//Default values
double Delta_max = 0;
//Calculation logic:
BeamFactoryData dat = new BeamFactoryData(L, P, M, w, a_load, b_load, c_load, P1, P2, M1, M2, E, I);
BeamLoadFactoryLocator loc = new BeamLoadFactoryLocator();
IBeamLoadFactory loadFactory = loc.GetLoadFactory(BeamDeflectionCaseId, dat);
LoadBeam load = loadFactory.GetLoad(BeamDeflectionCaseId);
BeamInstanceFactory beamFactory = new BeamInstanceFactory(dat);
IAnalysisBeam bm = beamFactory.CreateBeamInstance(BeamDeflectionCaseId, load, null);
Delta_max = bm.GetMaximumDeflection();
return(new Dictionary <string, object>
{
{ "Delta_max", Delta_max }
});
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
switch (cl.Case)
{
case LoadDistributedSpecialCase.Triangle:
DistributedUniformlyIncreasingToBase b1 = new DistributedUniformlyIncreasingToBase(beam, cl.Value); //5D.1
beamForceCase = b1;
beamDeflectionCase = b1;
break;
case LoadDistributedSpecialCase.InvertedTriangle:
DistributedUniformlyDecreasingToBase b2 = new DistributedUniformlyDecreasingToBase(beam, cl.Value); //5D.2
beamForceCase = b2;
beamDeflectionCase = b2;
break;
default:
UniformLoad b3 = new UniformLoad(beam, cl.Value); //5B.1
beamForceCase = b3;
beamDeflectionCase = b3;
break;
}
}
if (load is LoadDistributedGeneral) //5C.1
{
LoadDistributedGeneral cl = load as LoadDistributedGeneral;
UniformPartialLoad b = new UniformPartialLoad(beam, cl.Value, cl.XLocationEnd);
beamForceCase = b;
beamDeflectionCase = b;
}
return(new BeamCase(beamForceCase, beamDeflectionCase));
}
//public BeamLoadFactory(IParameterExtractor Extractor)
//{
// this.ParameterExtractor = Extractor;
//}
public LoadBeam GetLoad(string BeamCaseId)
{
LoadBeam Load = null;
string LoadGroup = BeamCaseId.Substring(1, 1); //simple, overhang, etc
string loadingType = BeamCaseId.Substring(2, 1); //A-concentrated, B-distributed etc ...
string subCase = BeamCaseId.Substring(BeamCaseId.Length - 1, 1); // specific sub-case
//L = ParameterExtractor.GetParam("L");
//P = ParameterExtractor.GetParam("P");
//M = ParameterExtractor.GetParam("M");
//w = ParameterExtractor.GetParam("w");
//LoadDimension_a = ParameterExtractor.GetParam("LoadDimension_a");
//LoadDimension_b = ParameterExtractor.GetParam("LoadDimension_b");
//LoadDimension_c= L-LoadDimension_a-LoadDimension_b; //e.GetParam("LoadDimension_c");
//P1 = ParameterExtractor.GetParam("P1");
//P2 = ParameterExtractor.GetParam("P2");
//M1 = ParameterExtractor.GetParam("M1");
//M2 = ParameterExtractor.GetParam("M2");
Load = GetBeamLoad(loadingType, subCase);
return(Load);
}
public static Dictionary <string, object> BeamForces(string BeamForcesCaseId, double L, double X = 0, double P = 0, double M = 0, double w = 0, double a_load = 0, double b_load = 0, double c_load = 0, double P1 = 0, double P2 = 0, double M1 = 0, double M2 = 0)
{
//Default values
double M_max = 0;
double M_min = 0;
double V_max = 0;
double M_x = 0;
double V_x = 0;
//Calculation logic:
BeamFactoryData dat = new BeamFactoryData(L, P, M, w, a_load, b_load, c_load, P1, P2, M1, M2);
BeamLoadFactoryLocator loc = new BeamLoadFactoryLocator();
IBeamLoadFactory loadFactory = loc.GetLoadFactory(BeamForcesCaseId, dat);
LoadBeam load = loadFactory.GetLoad(BeamForcesCaseId);
BeamInstanceFactory beamFactory = new BeamInstanceFactory(dat);
IAnalysisBeam bm = beamFactory.CreateBeamInstance(BeamForcesCaseId, load, null);
M_x = bm.GetMoment(X);
V_x = bm.GetShear(X);
M_max = bm.GetMomentMaximum().Value;
M_min = bm.GetMomentMinimum().Value;
V_max = bm.GetShearMaximumValue().Value;
return(new Dictionary <string, object>
{
{ "M_max", M_max }
, { "M_min", M_min }
, { "V_max", V_max }
, { "M_x", M_x }
, { "V_x", V_x }
});
}
public virtual LoadBeam GetMomentCase(string subCase)
{
LoadBeam Load = null;
switch (subCase)
{
case "1":
Load = new LoadMomentLeftEnd(d.M);
break;
case "2":
Load = new LoadMomentGeneral(d.M, d.a_load);
break;
case "3":
Load = new LoadMomentBothEnds(d.M1, d.M2);
break;
case "4":
Load = new LoadMomentRightEnd(d.M);
break;
}
return(Load);
}
public BeamFixedFixed(double Length, LoadBeam Loads, ICalcLog CalcLog)
: base(Length, Loads, CalcLog , new BeamFixedFixedFactory())
{
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadMomentLeftEnd)//1E.1
{
LoadMomentLeftEnd cl = load as LoadMomentLeftEnd;
MomentAtOneEnd b1 = new MomentAtOneEnd(beam, cl.Mo);
beamForceCase = b1;
beamDeflectionCase = b1;
}
if (load is LoadMomentGeneral)//1E.2
{
LoadMomentGeneral cl = load as LoadMomentGeneral;
MomentAtAnyPoint b2 = new MomentAtAnyPoint(beam, cl.Mo, cl.Location);
beamForceCase = b2;
beamDeflectionCase = null;
}
if (load is LoadMomentBothEnds)//1E.3
{
LoadMomentBothEnds cl = load as LoadMomentBothEnds;
beamForceCase = new MomentAtBothEnds(beam, cl.M1, cl.M2);
beamDeflectionCase = null;
}
if (load is LoadMomentRightEnd)//1E.4
{
LoadMomentRightEnd cl = load as LoadMomentRightEnd;
beamForceCase = new MomentAtFarEnd(beam, cl.Mo);
beamDeflectionCase = null;
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
public BeamFixedFixed(double Length, LoadBeam Loads, ICalcLog CalcLog)
: base(Length, Loads, CalcLog, new BeamFixedFixedFactory())
{
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
switch (cl.Case)
{
case LoadDistributedSpecialCase.Triangle:
DistributedUniformlyIncreasingToEnd b1 = new DistributedUniformlyIncreasingToEnd(beam, cl.Value);//1D.1
beamForceCase = b1;
beamDeflectionCase = b1;
break;
case LoadDistributedSpecialCase.DoubleTriangle:
DistributedDoubleTriangle b2 = new DistributedDoubleTriangle(beam, cl.Value); //1D.2
beamForceCase = b2;
beamDeflectionCase = b2;
break;
default:
UniformLoad b3 = new UniformLoad(beam, cl.Value); //1B.1
beamForceCase = b3;
beamDeflectionCase = b3;
break;
}
}
if (load is LoadDistributedUniformWithEndMoments) //1B.2
{
LoadDistributedUniformWithEndMoments cl = load as LoadDistributedUniformWithEndMoments;
beamForceCase = new UniformLoadAndEndMoments(beam, cl.Value, cl.M1, cl.M2);
beamDeflectionCase = null;
}
if (load is LoadDistributedGeneral) //1C.1
{
LoadDistributedGeneral cl = load as LoadDistributedGeneral;
beamForceCase = new UniformPartialLoad(beam, cl.Value, cl.XLocationStart, cl.XLocationEnd - cl.XLocationStart);
beamDeflectionCase = null;
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
private BeamCase GetConcentratedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
BeamCase beamCase = null;
if (load is LoadConcentratedSpecial) //4A.1
{
LoadConcentratedSpecial cl = load as LoadConcentratedSpecial;
ConcentratedLoadAtCenter b = new ConcentratedLoadAtCenter(beam, cl.P);
beamForceCase = b;
beamDeflectionCase = b;
}
if (load is LoadConcentratedGeneral) //4A.2
{
LoadConcentratedGeneral cl = load as LoadConcentratedGeneral;
ConcentratedLoadAnyPoint b = new ConcentratedLoadAnyPoint(beam, cl.P, cl.XLocation);
beamForceCase = b;
beamDeflectionCase = b;
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
public ISingleLoadCaseBeam GetForceCase(LoadBeam load, IAnalysisBeam beam)
{
BeamCase bc = GetCase(load, beam);
return bc.ForceCase;
}
private BeamCase GetDistributedLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
if (load is LoadDistributedUniform)
{
LoadDistributedUniform cl = load as LoadDistributedUniform;
switch (cl.Case)
{
case LoadDistributedSpecialCase.CantileverOverhang:
DistributedLoadOverhang b1 = new DistributedLoadOverhang(beam,cl.Value); //2C.2
beamForceCase = b1;
beamDeflectionCase = b1;
break;
case LoadDistributedSpecialCase.CantileverMainSpan:
DistributedLoadBetweenSupports b2 = new DistributedLoadBetweenSupports(beam, cl.Value); //2C.1
beamForceCase = b2;
beamDeflectionCase = b2;
break;
default:
UniformLoadFull b3 = new UniformLoadFull(beam, cl.Value); //2B.1
beamForceCase = b3;
beamDeflectionCase = b3;
break;
}
}
return new BeamCase(beamForceCase, beamDeflectionCase);
}
private BeamCase GetMomentLoadCase(LoadBeam load)
{
ISingleLoadCaseBeam beamForceCase = null;
ISingleLoadCaseDeflectionBeam beamDeflectionCase = null;
LoadMomentLeftEnd cl = load as LoadMomentLeftEnd; //3E.1
MomentAtFreeEnd b = new MomentAtFreeEnd(beam, cl.Mo);
beamForceCase = b;
beamDeflectionCase = b;
return new BeamCase(beamForceCase, beamDeflectionCase);
}
