Canguro.Analysis.LineStressCalculator.addToMomentDiagram C# (CSharp) Method

addToMomentDiagram() private method

private addToMomentDiagram ( LineLoad load, float dirComponent, float position, float lineLength ) : float
load LineLoad
dirComponent float
position float
lineLength float
return float
        private float addToMomentDiagram(LineLoad load, float dirComponent, float position, float lineLength)
        {
            if (load is ConcentratedSpanLoad)
            {
                float P = ((ConcentratedSpanLoad)load).L;
                float pDist = ((ConcentratedSpanLoad)load).D;

                if (position < (pDist * lineLength))
                    return P * dirComponent * (1f - pDist) * position;
                else
                    return P * dirComponent * pDist * (lineLength - position);
            }
            else if (load is DistributedSpanLoad)
            {
                DistributedSpanLoad dLoad = load as DistributedSpanLoad;

                //if (position >= 0)
                //    return -(dLoad.La * dirComponent * position / 2f) * (lineLength - position);

                float a, b, c, Ra, W, xt;
                a = dLoad.Da * lineLength;
                b = dLoad.Db * lineLength - a;
                c = lineLength - a - b;

                W = (dLoad.La + dLoad.Lb) * b / 2f;
                xt = Math.Abs(dLoad.La + dLoad.Lb) > float.Epsilon ? b * (dLoad.La + 2f * dLoad.Lb) / (3 * (dLoad.La + dLoad.Lb)) : 0.0f;
                Ra = W / lineLength * (lineLength - (a + xt));

                if (b == 0f)
                    return 0f;
                else if (position < a)
                {
                    return Ra * position * dirComponent;
                }
                else if (position <= (a + b))
                {
                    float Wx, y, xt2, y1;
                    y1 = (dLoad.Lb - dLoad.La) * (position - a) / b;
                    y = dLoad.La + y1;
                    xt2 = Math.Abs(dLoad.La + y) > float.Epsilon ? (position - a) / 3f * (dLoad.La + 2 * y) / (dLoad.La + y) : 0.0f;
                    Wx = (dLoad.La + y) * (position - a) / 2f;

                    return (Ra * position - Wx * (position - a - xt2)) * dirComponent;
                }
                else
                {
                    return (Ra * position - W * (position - a - xt)) * dirComponent;
                }
            }

            return 0f;
        }