public ForceDataPoint ShearMax()
{
ForceDataPoint V;
double V1 = Math.Abs(R1);
double V2 = Math.Abs(R2);
if (V1 > V2)
{
V = new ForceDataPoint(0.0, V1);
BeamEntryFactory.CreateEntry("Vx", V.Value, BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "R1", V1 },
{ "X", 0 },
}, CASE, beam, true);
}
else
{
V = new ForceDataPoint(L, V2);
BeamEntryFactory.CreateEntry("Vx", V.Value, BeamTemplateType.Vmax, 2,
new Dictionary <string, double>()
{
{ "R2", V2 },
{ "X", 0 },
}, CASE, beam, true);
}
return(V);
}
public double Moment(double X)
{
beam.EvaluateX(X);
double M;
Dictionary <string, double> valDic = new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P }
};
if (X <= L / 2.0)
{
M = P / 8.0 * (4 * X - L);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
valDic, CASE, beam);
}
else
{
M = P / 8.0 * (3 * L - 4 * X);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
valDic, CASE, beam);
}
return(M);
}
public ForceDataPoint MomentMin()
{
if (ReactionStateIsUpdated == false)
{
CalculateReactions();
}
if (Mmax == null)
{
Mmax = CalculateMmax();
}
if (w >= 0)
{
BeamEntryFactory.CreateEntry("Mx", 0.0, BeamTemplateType.M_zero, 0,
null, CASE, beam, false, true);
return(new ForceDataPoint(0.0, 0.0));
}
else
{
BeamEntryFactory.CreateEntry("Mx", Mmax.Value, BeamTemplateType.Mmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", Mmax.X },
{ "w", w },
{ "a", a },
{ "b", b },
{ "c", c },
}, CASE, beam, false, true);
return(Mmax);
}
}
public ForceDataPoint ShearMax()
{
double V1 = Math.Abs(CalculateV1());
double V2 = Math.Abs(CalculateV2());
if (V1 > V2)
{
BeamEntryFactory.CreateEntry("Vx", V1, BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", L },
{ "w", w },
{ "a", a },
}, CASE, beam, true);
return(new ForceDataPoint(L, V1));
}
else
{
BeamEntryFactory.CreateEntry("Vx", V2, BeamTemplateType.Vmax, 2,
new Dictionary <string, double>()
{
{ "X", L },
{ "w", w },
{ "a", a },
}, CASE, beam, true);
return(new ForceDataPoint(L, V2));
}
}
public double Moment(double X)
{
beam.EvaluateX(X);
if (ReactionsWereCalculated == false)
{
CalculateReactions();
}
double M;
double R1 = V1;
if (X <= a)
{
M = R1 * X;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "R1", R1 },
{ "X", X }
}, CASE, beam);
}
else
{
M = R1 * X - P * (X - a);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "R1", R1 },
{ "X", X },
{ "P", P },
{ "P", P },
{ "a", a }
}, CASE, beam);
}
return(M);
}
public ForceDataPoint MomentMin()
{
double Pabs = Math.Abs(P);
double M = -Pabs * L / 8.0;
double X;
if (P <= 0.0)
{
X = L / 2.0;
}
else
{
X = 0.0;
}
Dictionary <string, double> valDic = new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
};
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mmax, 1,
valDic, CASE, beam, false, true);
return(new ForceDataPoint(X, M));
}
public ForceDataPoint MomentMax()
{
double M;
if (P > 0.0)
{
M = P * a * b / L;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", a },
{ "P", P },
{ "a", a },
{ "b", b }
}, CASE, beam, true);
}
else
{
M = 0.0;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.M_zero, 0,
null, CASE, beam, true);
}
return(new ForceDataPoint(a, M));
}
public ForceDataPoint ShearMax()
{
double V1A = Math.Abs(V1);
double V2A = Math.Abs(V2);
double X;
Dictionary <string, double> valDic = new Dictionary <string, double>()
{
{ "L", L },
{ "P", P },
{ "a", a },
{ "b", b }
};
if (V1A > V2A)
{
valDic.Add("X", a);
BeamEntryFactory.CreateEntry("Vx", V1A, BeamTemplateType.Vmax, 1,
valDic, CASE, beam, true);
X = a;
return(new ForceDataPoint(X, V1A));
}
else
{
X = L;
valDic.Add("X", L);
BeamEntryFactory.CreateEntry("Vx", V1A, BeamTemplateType.Vmax, 2,
valDic, CASE, beam, true);
return(new ForceDataPoint(X, V2A));
}
}
void CalculateReactions()
{
// double V = P * b * b / (2.0 * Math.Pow(L, 3)) * (a + 2.0 * L);
// double V = P*a/(2.0*Math.Pow(L,3))*(3.0*L*L-a*a);
Dictionary <string, double> valDic = new Dictionary <string, double>()
{
{ "L", L },
{ "P", P },
{ "a", a },
{ "b", b }
};
double R1 = V1;
BeamEntryFactory.CreateEntry("R1", R1, BeamTemplateType.R, 1,
valDic, CASE, beam);
double R2 = V2;
BeamEntryFactory.CreateEntry("R2", R2, BeamTemplateType.R, 2,
valDic, CASE, beam);
ReactionsWereCalculated = true;
}
public double Deflection(double X)
{
double delta;
double E = beam.ModulusOfElasticity;
double I = beam.MomentOfInertia;
int CaseId = 1;
if (X <= L / 2.0)
{
delta = (P * X) / (48 * E * I) * (3 * Math.Pow(L, 2.0) - 4 * Math.Pow(X, 2.0));
CaseId = 1;
}
else
{
delta = (P * (L - X)) / (48 * E * I) * (3 * Math.Pow(L, 2.0) - 4 * Math.Pow(L - X, 2.0));
CaseId = 2;
}
BeamEntryFactory.CreateEntry("delta", delta, BeamTemplateType.deltaMax, CaseId,
new Dictionary <string, double>()
{
{ "X", X },
{ "P", P },
{ "E", E },
{ "I", I },
{ "L", L }
}, CASE, beam);
return(delta);
}
public ForceDataPoint MomentMin()
{
double M;
if (P > 0.0)
{
M = 0.0;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.M_zero, 0,
null, CASE, beam, false, true);
}
else
{
M = P * L / 4.0;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", L / 2.0 },
{ "P", P },
}, CASE, beam, false, true);
}
return(new ForceDataPoint(L / 2.0, M));
}
public double Moment(double X)
{
beam.EvaluateX(X);
double M;
if (X <= L / 2.0)
{
M = P * X / 2.0;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "X", X },
{ "P", P }
}, CASE, beam);
return(M);
}
else
{
M = P * (L - X) / 2.0;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P }
}, CASE, beam);
}
return(M);
}
public double Moment(double X)
{
double M;
beam.EvaluateX(X);
if (X <= L / 2.0)
{
M = (P / 2.0 + (M1 - M2) / L) * X - M1;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "M1", M1 },
{ "M2", M2 },
}, CASE, beam);
}
else
{
M = P / 2.0 * (L - X) + ((M1 - M2) * X) / L - M1;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "M1", M1 },
{ "M2", M2 },
}, CASE, beam);
}
return(M);
}
public double Shear(double X)
{
beam.EvaluateX(X);
double V;
if (X < a)
{
V = GetShearLeft();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "b", b }
}, CASE, beam);
}
else if (X > a)
{
V = GetShearRight();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "a", a }
}, CASE, beam);
}
else
{
if (a > b)
{
V = GetShearRight();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "a", a }
}, CASE, beam);
}
else // at the point of load
{
V = GetShearLeft();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "P", P },
{ "b", b }
}, CASE, beam);
}
}
return(V);
}
public ForceDataPoint ShearMax()
{
double V;
if (a > b)
{
V = GetShearRight();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vmax, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", a },
{ "P", P },
{ "a", a },
}, CASE, beam, true);
}
else
{
V = GetShearLeft();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", a },
{ "P", P },
{ "b", b },
}, CASE, beam, true);
}
return(new ForceDataPoint(a, V));
}
public ForceDataPoint MomentMin()
{
if (ReactionsWereCalculated == false)
{
CalculateReactions();
}
if (DimensionsWereCalculated == false)
{
CalculateDimensions();
}
double M, X;
if (w < 0)
{
M = M1;
X = M1Location;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mmax, 1,
new Dictionary <string, double>()
{
{ "X", X },
{ "w", w },
{ "R1", R1 },
{ "a", a }
}, CASE, beam, false, true);
}
else
{
M = MSupport;
X = L;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mmax, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", L },
{ "w", w },
{ "a", a },
{ "b", b },
{ "c", c },
{ "d", d },
{ "e", e }
}, CASE, beam, false, true);
}
return(new ForceDataPoint(X, M));
//double M = double.PositiveInfinity;
//double Xgovern = 0;
//beam.LogModeActive = false;
//List<double> Stations = CreateStationList();
//foreach (var sta in Stations)
//{
// double Mcurrent = Moment(sta);
// M = Mcurrent < M ? Mcurrent : M;
// Xgovern = Mcurrent < M ? sta : Xgovern;
//}
//beam.LogModeActive = true;
//return CreateEntry(Xgovern, M, false, true);
}
public ForceDataPoint ShearMax()
{
double V = P;
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vmax, 1,
null, CASE, beam, true);
return(new ForceDataPoint(a, V));
}
public ForceDataPoint ShearMax()
{
double V = CalculateShear();
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vmax, 1,
null, CASE, beam, true);
return(new ForceDataPoint(0.0, Math.Abs(V)));
}
private void Calculate_e()
{
this.e = c + b / 2.0;
BeamEntryFactory.CreateEntry("e", e, BeamTemplateType.e, 1,
new Dictionary <string, double>()
{
{ "b", b },
{ "c", c }
}, CASE, beam);
}
public ForceDataPoint ShearMax()
{
double V = 0.0;
BeamEntryFactory.CreateEntry("Vx", Math.Abs(V), BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "X", 0.0 }
}, CASE, beam, true);
return(new ForceDataPoint(0.0, Math.Abs(V)));
}
public ForceDataPoint ShearMax()
{
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", 0.0 },
{ "Mo", Mo }
}, CASE, beam, true);
return(new ForceDataPoint(0.0, V));
}
private void CalculateX1(double X)
{
X1 = X1 - L;
BeamEntryFactory.CreateEntry("X1", X1, BeamTemplateType.Mmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
}, CASE, beam, true);
X1Calculated = true;
}
public double Shear(double X)
{
double V = 0.0;
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "X", X }
}, CASE, beam);
return(V);
}
public double Shear(double X)
{
beam.EvaluateX(X);
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "Mo", Mo }
}, CASE, beam);
return(V);
}
public double Moment(double X)
{
beam.EvaluateX(X);
double M;
if (ReactionStateIsUpdated == false)
{
CalculateReactions();
}
if (X <= a)
{
//left-hand segment
M = R1 * X;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "R1", R1 }
}, CASE, beam);
}
else
{
if (X >= L - b)
{
//right hand side segment
M = R2 * (L - X);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 3,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "R2", R2 }
}, CASE, beam);
}
else
{
//middle segment
M = R1 * X - w / 2.0 * Math.Pow(X - a, 2);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "w", w },
{ "a", a },
{ "R1", R1 }
}, CASE, beam);
}
}
return(M);
}
public double Moment(double X)
{
beam.EvaluateX(X);
if (ReactionsWereCalculated == false)
{
CalculateReactions();
}
if (DimensionsWereCalculated == false)
{
CalculateDimensions();
}
double M;
if (X <= a) //left-hand segment
{
M = R1 * X;
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "R1", R1 },
{ "X", X }
}, CASE, beam);
}
else if (X >= a + b) //right-hand segment
{
M = R1 * X - w * b * (X - d);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 3,
new Dictionary <string, double>()
{
{ "R1", R1 },
{ "X", X },
{ "w", w },
{ "d", d },
{ "b", b }
}, CASE, beam);
}
else
{
M = R1 * X - w / 2.0 * Math.Pow(X - a, 2);
BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "w", w },
{ "R1", R1 },
{ "a", a },
}, CASE, beam);
}
return(M);
}
public double Shear(double X)
{
beam.EvaluateX(X);
if (ReactionStateIsUpdated == false)
{
CalculateReactions();
}
double V;
if (X <= a)
{
//left-hand segment
V = R1;
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "R1", R1 },
}, CASE, beam);
}
else
{
if (X >= L - b)
{
//right hand side segment
V = R2;
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 3,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "R2", R2 },
}, CASE, beam);
}
else
{
//middle segment
V = R1 - w * (X - a);
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", X },
{ "R1", R1 },
{ "w", w },
{ "a", a }
}, CASE, beam);
}
}
return(V);
}
public ForceDataPoint ShearMax()
{
double Vmax = R2;
BeamEntryFactory.CreateEntry("Vx", Vmax, BeamTemplateType.Vmax, 1,
new Dictionary <string, double>()
{
{ "L", L },
{ "X", L },
{ "w", w }
}, CASE, beam, true);
return(new ForceDataPoint(L, Vmax));
}
public ForceDataPoint ShearMax()
{
double V = Math.Abs(P);
BeamEntryFactory.CreateEntry("Vx", V, BeamTemplateType.Vx, 1,
new Dictionary <string, double>()
{
{ "X", L },
{ "P", P }
}, CASE, beam);
return(new ForceDataPoint(a, V));
}
public double Moment(double X)
{
beam.EvaluateX(X);
double Mx = Mo;
BeamEntryFactory.CreateEntry("Mx", Mx, BeamTemplateType.Mx, 1,
new Dictionary <string, double>()
{
{ "X", X },
{ "Mo", Mo },
}, CASE, beam);
return(Mx);
}
