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

        public float[,] GetForcesDiagram(AbstractCase ac, LineElement line, LineForceComponent component, int numPoints)
        {
            if (!model.HasResults) return null;

            float[,] controlPoints = new float[numPoints, 2];

            float[] controlPointsX = new float[1]; // requestXCtrlPts(load);
            for (int i = 0, bufi = 0; i < numPoints; i++)
            {
                controlPoints[i,0] = i / (numPoints - 1f);

                // Adjust control points
                if ((bufi < controlPointsX.Length) && (controlPointsX[bufi] <= controlPoints[i, 0]))
                    controlPoints[i, 0] = controlPointsX[bufi++];

                controlPoints[i, 1] = 0f; // controlPoints[i, 0] * (fdJ - fdI);
            }

            float fI, fJ;
            getForcesDiagram(ac, line, component, controlPoints, out fI, out fJ);

            for (int i = 0, bufi = 0; i < numPoints; i++)
            {
                // Los valores en los nodos se encuentran volteados. Del lado izquierdo positivo
                // es arriba, mientras del lado derecho positivo es abajo, por lo que si se tienen
                // dos valores positivos se debería pintar una recta con pendiente negativa y si
                // se tienen dos negativos al revés. DeltaY = Y1 + Y2 (por el cambio de signo).
                controlPoints[i, 1] += controlPoints[i, 0] * (fI + fJ) - fI;
            }

            return controlPoints;
        }

        private bool recalculateMinMaxStressesOfSelection(Canguro.Model.Model model)
        {
            if (!model.HasResults || model.Results.ActiveCase == null)
            {
                return(false);
            }

            Model.Load.AbstractCase ac = model.Results.ActiveCase.AbstractCase;
            int numPoints = Properties.Settings.Default.ElementForcesSegments;

            LineStressCalculator lsc = new LineStressCalculator();

            Model.Section.FrameSection section;
            StraightFrameProps         sfProps;

            Vector2[][] contour;
            float       stress;

            float[,] s1, m22, m33;

            foreach (LineElement line in model.LineList)
            {
                if (line != null && line.IsVisible)
                {
                    sfProps = line.Properties as StraightFrameProps;
                    if (sfProps != null)
                    {
                        s1  = lsc.GetForcesDiagram(ac, line, Canguro.Model.Load.LineForceComponent.Axial, numPoints);
                        m22 = lsc.GetForcesDiagram(ac, line, Canguro.Model.Load.LineForceComponent.Moment22, numPoints);
                        m33 = lsc.GetForcesDiagram(ac, line, Canguro.Model.Load.LineForceComponent.Moment33, numPoints);

                        section = sfProps.Section;
                        contour = section.Contour;
                        for (int j = 0; j < numPoints; j++)
                        {
                            for (int i = 0; i < contour[0].Length; i++)
                            {
                                stress = lsc.GetStressAtPoint(section, s1, m22, m33, j, contour[0][i].X, contour[0][i].Y);
                                if (stress > maxStress)
                                {
                                    maxStress = stress;
                                }
                                if (stress < minStress)
                                {
                                    minStress = stress;
                                }
                            }
                        }
                    }
                }
            }
            return(true);
        }