Beispiel #1
0
        public void CalcEquivalentlReactions(ComponentLoad DistributedLoad)
        {
            // Разложим load на составляющие в локальной системе для
            cosa = Math.Cos((DistributedLoad.Direction - AngleD) * Math.PI / 180);
            sina = Math.Sin((DistributedLoad.Direction - AngleD) * Math.PI / 180);
            cosL = Math.Cos(Angle);
            sinL = Math.Sin(Angle);
            qx   = DistributedLoad.Value * cosa;
            qy   = DistributedLoad.Value * sina;
            // Находим реакции
            // 1. Если в обоих узлах элемента нет шарниров
            // 2. Если шарнир в первом узле
            // 3. Если шарнир во втором узле
            // 4. Если шарниры в обоих узлах
            rx1 = qx * Length / 2;
            rx2 = rx1;
            if ((!HingeStart) && (!HingeEnd))
            {
                ry1 = qy * Length / 2;
                ry2 = ry1;
                //TODO: Разобраться со знаками моментов
                m1 = qy * (Length * Length) / 12;
                m2 = -m1;
            }
            if ((HingeStart) && (!HingeEnd))
            {
                ry2 = qy * 5 / 8 * Length;
                ry1 = qy * Length - ry2;
                m2  = -qy *Math.Pow(Length, 2) / 8;

                m1 = 0;
            }
            if ((!HingeStart) && (HingeEnd))
            {
                ry1 = qy * 5 / 8 * Length;
                ry2 = qy * Length - ry1;
                m1  = qy * Math.Pow(Length, 2) / 8;
                m2  = 0;
            }
            if ((HingeStart) && (HingeEnd))
            {
                ry1 = qy * Length / 2;
                ry2 = ry1;
                m1  = 0;
                m2  = 0;
            }
            CleanupReactions();
        }
        public void Load(Stream stream, ObservableCollection <ComponentBasic> DestinationList)
        {
            XmlDocument doc = new XmlDocument();

            stream.Seek(0, SeekOrigin.Begin);
            doc.Load(stream);

            DestinationList.Clear();

            for (int i = 0; i < doc.DocumentElement.ChildNodes.Count; i++)
            {
                XmlNode n = doc.DocumentElement.ChildNodes[i];
                if (n.Name == "x:Nodes")
                {
                    for (int j = 0; j < n.ChildNodes.Count; j++)
                    {
                        XmlNode       node = n.ChildNodes[j];
                        float         x    = float.Parse(GetAttrValue(node.Attributes["x:X"], "0"));
                        float         y    = float.Parse(GetAttrValue(node.Attributes["x:Y"], "0"));
                        bool          dx   = bool.Parse(GetAttrValue(node.Attributes["x:DX"], "false"));
                        bool          dy   = bool.Parse(GetAttrValue(node.Attributes["x:DY"], "false"));
                        bool          r    = bool.Parse(GetAttrValue(node.Attributes["x:Rotation"], "false"));
                        ComponentNode cn   = new ComponentNode(new IssoPoint2D()
                        {
                            X = x, Y = y
                        });
                        if (dx)
                        {
                            cn.DisallowedDisplacements.Add(NodeDisplacement.X);
                        }
                        if (dy)
                        {
                            cn.DisallowedDisplacements.Add(NodeDisplacement.Y);
                        }
                        if (r)
                        {
                            cn.DisallowedDisplacements.Add(NodeDisplacement.Rotation);
                        }
                        DestinationList.Add(cn);
                    }
                }
                List <ComponentNode> modelNodes = ModelNodes2(DestinationList);
                if (n.Name == "x:Beams")
                {
                    for (int j = 0; j < n.ChildNodes.Count; j++)
                    {
                        XmlNode beam = n.ChildNodes[j];
                        int     sn   = int.Parse(GetAttrValue(beam.Attributes["x:StartNode"], "0"));
                        int     en   = int.Parse(GetAttrValue(beam.Attributes["x:EndNode"], "0"));

                        ComponentLinear cl = new ComponentLinear(modelNodes[sn], modelNodes[en], this);
                        DestinationList.Add(cl);
                    }
                }
                if (n.Name == "x:Forces")
                {
                    for (int j = 0; j < n.ChildNodes.Count; j++)
                    {
                        XmlNode force = n.ChildNodes[j];
                        int     ni    = int.Parse(GetAttrValue(force.Attributes["x:Node"], "0"));
                        float   d     = float.Parse(GetAttrValue(force.Attributes["x:Direction"], "0"));
                        float   v     = float.Parse(GetAttrValue(force.Attributes["x:Value"], "0"));

                        ComponentLoad cl = new ComponentLoad(ComponentTypes.ctForce, v, modelNodes[ni]);
                        cl.Direction = d;
                        DestinationList.Add(cl);
                    }
                }
                List <ComponentLinear> modelBeams = ModelBeams2(DestinationList);
                if (n.Name == "x:DistributedLoads")
                {
                    for (int j = 0; j < n.ChildNodes.Count; j++)
                    {
                        XmlNode load = n.ChildNodes[j];
                        int     li   = int.Parse(GetAttrValue(load.Attributes["x:Beam"], "0"));
                        float   d    = float.Parse(GetAttrValue(load.Attributes["x:Direction"], "0"));
                        float   v    = float.Parse(GetAttrValue(load.Attributes["x:Value"], "0"));

                        ComponentLoad cl = new ComponentLoad(ComponentTypes.ctDistributedLoad, v, modelBeams[li]);
                        cl.Direction = d;
                        DestinationList.Add(cl);
                    }
                }
            }
        }
        internal void CalculateStatic()
        {
            // Статический расчёт!

            // 0. Разбиваем модель на элементы:
            //    Незагруженные распределённой нагрузкой стержни берём целиком,
            //    в противном случае - делим стержень на несколько элементов
            // 1. Создаём список узлов
            Nodes.Clear();
            for (int i = 0; i < CompsList.Count; i++)
            {
                if (CompsList[i].CompType == ComponentTypes.ctNode)
                {
                    Nodes.Add((ComponentNode)CompsList[i]);
                }
            }
            // В соответствии с количеством узлов создаём матрицу жёсткости системы и заполняем её нулями
            // Для каждого узла - три возможных перемещения
            // 0 - горизонтальное
            // 1 - вертикальное
            // 2 - поворот
            GlobalMatrix = new double[Nodes.Count * 3, Nodes.Count * 3];
            for (int i = 0; i < Nodes.Count; i++)
            {
                for (int j = 0; j < Nodes.Count; j++)
                {
                    GlobalMatrix[i, j] = 0;
                }
            }

            // 2. Создаём балочные элементы и заполняем глобальную матрицу
            Rods.Clear();
            for (int i = 0; i < CompsList.Count; i++)
            {
                if (CompsList[i].CompType == ComponentTypes.ctLinear)
                {
                    ComponentNode n1  = ((ComponentLinear)CompsList[i]).StartNode;
                    ComponentNode n2  = ((ComponentLinear)CompsList[i]).EndNode;
                    int           n1i = getNodeIndex(n1);
                    int           n2i = getNodeIndex(n2);
                    ElementBeam   b   = new ElementBeam((ComponentLinear)CompsList[i], this);
                    Rods.Add(b);
                    // Встраиваем матрицу жёсткости элемента в глобальную матрицу жёсткости
                    for (int row = 0; row < 6; row++)
                    {
                        for (int col = 0; col < 6; col++)
                        {
                            int r, c;
                            if (row < 3)
                            {
                                r = n1i * 3 + row;
                            }
                            else
                            {
                                r = n2i * 3 + row - 3;
                            }
                            if (col < 3)
                            {
                                c = n1i * 3 + col;
                            }
                            else
                            {
                                c = n2i * 3 + col - 3;
                            }
                            GlobalMatrix[r, c] += b.ExtMatrix[row, col];
                        }
                    }
                }
            }

            // 3. Создаём вектор узловых сил.
            Loads = new double[Nodes.Count * 3];
            for (int i = 0; i < Loads.Length; i++)
            {
                Loads[i] = 0;
            }
            for (int i = 0; i < CompsList.Count; i++)
            {
                if (CompsList[i].CompType == ComponentTypes.ctForce)
                {
                    ComponentLoad load = (ComponentLoad)CompsList[i];
                    ComponentNode n    = load.AppNodes[0];
                    // Сила приложена к узлу, её нужно разложить на
                    // две составляющие в глобальной системе координат
                    // - горизонтальную и вертикальную
                    // Поскольку в одном узле может быть несколько сил -
                    // складываем их
                    double force  = load.Value;
                    double cosa   = Math.Cos(load.Direction / 180 * Math.PI);
                    double sina   = Math.Sin(load.Direction / 180 * Math.PI);
                    double forceX = force * cosa;
                    double forceY = force * sina;
                    int    ind    = getNodeIndex(n) * 3;
                    // При этом, если в узле есть связь, запрещающая перемещения по указанному направлению, то
                    // соответствующую часть силы обнуляем
                    if (ind > -1)
                    {
                        // Сила по X
                        if (!n.DisallowedDisplacements.Contains(NodeDisplacement.X))
                        {
                            Loads[ind] += forceX;
                        }
                        // Сила по Y
                        if (!n.DisallowedDisplacements.Contains(NodeDisplacement.Y))
                        {
                            Loads[ind + 1] += forceY;
                        }
                    }
                }

                if (CompsList[i].CompType == ComponentTypes.ctDistributedLoad)
                {
                    // Распределённую нагрузку приводим к узловой
                    ComponentLoad   load = (ComponentLoad)CompsList[i];
                    ComponentLinear lc   = load.Beam;
                    // Найдём элемент, созданный на основе компонента lc и сообщим ему,
                    // что на нём лежит нагрузка load
                    ElementBeam beam = Rods.Find(b => b.Linear == lc);
                    if (beam != null)
                    {
                        beam.CalcEquivalentlReactions(load);
                        int ind = getNodeIndex(lc.StartNode) * 3;
                        if (ind > -1)
                        {
                            // Сила по X
                            if (!lc.StartNode.DisallowedDisplacements.Contains(NodeDisplacement.X))
                            {
                                Loads[ind] += beam.Rx1g;
                            }
                            // Сила по Y
                            if (!lc.StartNode.DisallowedDisplacements.Contains(NodeDisplacement.Y))
                            {
                                Loads[ind + 1] += beam.Ry1g;
                            }
                            // Момент
                            if (!lc.StartNode.DisallowedDisplacements.Contains(NodeDisplacement.Rotation))
                            {
                                Loads[ind + 2] += beam.M1g;
                            }
                        }
                        ind = getNodeIndex(lc.EndNode) * 3;
                        if (ind > -1)
                        {
                            // Сила по X
                            if (!lc.EndNode.DisallowedDisplacements.Contains(NodeDisplacement.X))
                            {
                                Loads[ind] += beam.Rx2g;
                            }
                            // Сила по Y
                            if (!lc.EndNode.DisallowedDisplacements.Contains(NodeDisplacement.Y))
                            {
                                Loads[ind + 1] += beam.Ry2g;
                            }
                            // Момент
                            if (!lc.EndNode.DisallowedDisplacements.Contains(NodeDisplacement.Rotation))
                            {
                                Loads[ind + 2] += beam.M2g;
                            }
                        }
                    }
                }
            }

            // 4. Применяем ограничения
            for (int i = 0; i < CompsList.Count; i++)
            {
                if (CompsList[i].CompType == ComponentTypes.ctNode)
                {
                    Block((ComponentNode)CompsList[i]);
                }
            }
            // 5. Получаем перемещения узлов в глобальной системе координат
            double[,] GlobalInverted = StarMath.inverse(GlobalMatrix);
            Displacements            = StarMath.multiply(GlobalInverted, Loads);
            // "Подчистим" перемещения от сверхмалых значений
            CleanupDisplacements();
            // Определим значения реакций в узлах - они же внутренние усилия
            for (int i = 0; i < Rods.Count; i++)
            {
                Rods[i].CalculateForces();
            }
        }