Исследование метода конечных элементов (МКЭ)



Аннотация

Эта работа посвящена исследованию метода конечных элементов (МКЭ) и его непосредственного применения в различных научных сферах, в области техники и технологии. Поднятая проблема имеет первостепенное значение для исследования ферменных конструкции. В рамках этого исследования была поставлена задача - прояснить вопрос о методе конечных элементов, его истории и практическому использованию. Такой метод часто используется в компьютерной индустрии, как практический инструмент для инженерного анализа.

Была смоделирована ферма Пратта под действием заданных усилий на языке программирования MATLAB. Также  было решены оптимизационные задачи для разных характеристик фермы. Полученный алгоритм программы был перенесен на язык JAVA в Android Studio.

Результаты исследования могут быть полезны при моделировании различных ферменных  конструкции в строительной механики.

Abstract

This work is devoted to the study of finite element method (FEM) and its direct application in various scientific fields, in the field of engineering and technology. The raised problem is of paramount importance for the study of truss construction. There was a task - to clarify the question of the finite element method, its history and its practical use. This method is often used in the computer industry, as a practical tool for engineering analysis.

Pratt truss was modeled under the influence of a predetermined force on the MATLAB programming language. It was also resolved optimization problems for different characteristics of the truss. The resulting algorithm for the program was moved to the JAVA language on Android Studio.

Results of the study can be useful for modeling various truss structure in structural mechanics.

Содержание

Введение. (5)

1 Обзор проблематики. Постановка задачи. (6)

1.1 История метода конечных элементов. Известные исследователи и научные работы в области. (6)

1.2 Основные определения и способы реализации МКЭ.(8)

      1.2.1  Ферменная конструкция.  (10)

      1.2.2 Метод прямой жесткости.  (1)

1.3 Необходимые технологии и программное обеспечение. Цели и задачи работы. Итоги первой части.(15)

2  Необходимые алгоритмы реализации метода конечных элементов. (16)

2.1 Теоретические аспекты поставленной задачи. (16)

2.2 Программирование подAndroid.(24)

3 Результаты исследования.(26)

3.1  Реализация метода конечных элементов на языке программированияMATLAB.(28)

3.2 Реализация метода конечных элементов на языке программированияJAVA под ОСAndroid.(31)

Заключение. (33)

Приложение 1. Программа на языкеMATLAB.(34)

Приложение 2. Программа на языкеJAVA вAndroidStudio.(35)

Введение.

Метод конечных элементов (МКЭ) жесткости возник в аэрокосмической отрасли. Исследователи рассматривали различные подходы к анализу сложных частей самолета, используя при этом теорию упругости, энергетический принцип в строительной механике, метод гибкости и метод матрицы жесткости. На основе анализа этих методов возник метод прямой жесткости, который был разработан для эффективной оценки сложных структур, содержащих большое количество элементов. Он широко применяется в моделировании структурного анализа.

В данной выпускной квалификационной работе рассмотрена история МКЭ, известные исследователи в этой области. Были даны необходимые определения, определено нужное программное обеспечение. Также представлены теоретические аспекты метода. В результате были получены программы на языкеJAVA  вAndroidStudio иMATLAB, в которой задаются свойства элементов и различные условия нагрузки, программа автоматически оценивает конструкцию и генерирует прогиб конструкции для пользователя.

1Обзор проблематики. Постановка задачи.

1.1История метода конечных элементов. Известные исследователи и научные работы в области.

Историческими предшественниками метода конечных элементов (МКЭ) были различные методы строительной механики и механики деформируемого твёрдого тела. В 19 векефранцузский математик и физик Пуассон предлагал рассматривать сплошную среду как систему конечных объёмов, а Д. Максвеллом и А. Кастильяно были заложены основы анализа стержневых конструкций. После этого были сформулированы метод сил и затем метод перемещений. Благодаря техническому прогрессу в 20 веке произошло быстрое развитие в области авиации и космонавтики, что поспособствовало возникновению различных матричных методов анализа конструкций. Значительный вклад в развитие строительной механики внес Д. Аргирис.

Первое сообщение о расчете конструкций методом конечных элементов появилось в 1956 г. в статьеМ.Тернера, Р. Клафа, Г. Мартина и Л. Топпа.Р. Клаф в 1960 г. ввёл термин «конечные элементы». [10]В 1959 Д.Тернер предложил метод прямой жесткости в качестве компьютерной реализации метода конечных элементов.В 1963 году метод получил широкую известность после того, как была доказана его связь с методом Рэлея — Ритца, который сводит поставленную задачу к системе линейных уравнений равновесия иищет приближенное решение. Область применения МКЭ значительно расширилась в 1968 году. Было установлено, что уравнения, определяющие элементы в задачах, могут быть получены с помощью метода Галёркина или метода наименьших квадратов. Эти факты повлияли на обоснование МКЭ, который стал применяться для численного решения дифференциальных уравнений и построения дискретных аппроксимаций.[9]

Дальнейшие исследования были нацелены на получение программного обеспечения с открытым исходным кодом для реализации этого метода. В конце 1960-xNASA выпустило ПОNASTRAN для аэрокосмического анализа.[6]Строгое математическое обоснование для метода конечных элементов был представлено в 1973 году Джорджом Фиксом и Гильбертом Стренгом. Наиболее известная их публикация – «Теория метода конечных элементов». В ней рассматриваетсявлияние различных факторов на вычислительную эффективность метода конечных элементов. [7]

В настоящее время существует большое количество современных МКЭ комплексов, такие, как Ansys, MSC/Nastran или SAP-7,включающих в себя тепловые, жидкостные и структурные компоненты. Появление таких продуктов позволило ускорить процесс проектирования объектоваэрокосмической, авиационной или машиностроительной отрасли в десятки раз.[8]

1.2 Основные определения и способы реализации МКЭ.

Метод конечных элементов является численным методом для нахождения приближенных решений физических задач. В основе этого метода лежит разделение поставленной задачи на несколько частей, состоящих из конечных элементов иузловых точек. Полученнаяструктура -конечно-элементная модель, должна быть проста для хранения и опознавания с помощью ЭВМ.

Разделение конструкции на мелкие части имеет ряд преимуществ:

1. Точное представлениегеометрические особенности областей.

2. Представление общего решения поставленной задачи.

3.Вариация размеров конечных элементов.

4. Учет краевых условий.

МКЭ является очень гибким методом.Исследуемые объекты могут иметь любую форму, размеры и физическую природу. Возможно проводить моделирование разных граничных условий. Вычислительный алгоритм, представленный в матричной форме, единообразен для рассматриваемых задач, что удобно для компьютерной реализации. Система уравнений имеет симметричную матрицу «жёсткости», что ускоряет вычислительный процесс на ЭВМ.

Этапы применения МКЭ к анализу поведения строительных конструкций являются:

1) Определяются аппроксимирующие функции на элементе для характеристики точек.

2) Вычисляются зависимости данных функций от значений в узлах.

Узлы расположены в вершинах и, возможно, в гранях элемента или внутри элемента.

3) Формируется матрица жесткости элемента, связывающая значения узловых перемещений со значениями усилий в узлах элемента.

4)  Получение из локальных функций элементов кусочно-непрерывной функции, определенной на всей области. Формирование глобальных матриц жесткости.

5) Решение полученных дискретных уравнений равновесия или движения относительно неизвестных в узлах.

6) Вычисление характеристик напряженно-деформированного состояния.[8]

Итак, метод конечных элементов используется в качестве инструмента для инженерного анализа, рассматривается процедура изготовления сетки для разделения сложной задачи на несколько частей. МКЭ указывает на распределение напряжений и перемещений. МКЭ позволяет оптимизировать всю конструкцию до производства. Преимущества МКЭ заключаются в  уменьшении времени на разработки продукта от концепции до производственной линии, повышении производительности.Наибольшая трудность при этом — достижение удобства и простоты вычислений. [2] [3] [4] [5][7]

1.2.1  Ферменная конструкция.

Ферменная конструкция представляет собой стержневую систему. При замене жёстких узлов  шарнирами, она остается геометрически неизменяемой иудовлетворяет следующим требования:

А) Элементы должны быть прямыми и тонкими. Поперечное сечение мало по сравнению с длиной элементов.

Б) Вес элементов невелик по сравнению с приложенными силами. Кроме того, при построении

В) Усилия прикладываются только к узлам в виде сосредоточенной силы.

Г) К элементу прикладывается только две силы, следовательно, рассматриваются только осевые усилия.

Д) В большинстве случаев элемент фермы ведет себя, как линейная пружина.

Если несколько стержней конструкции произвольным образом скрепить на шарнирах, то они будут крутиться друг около друга, и при некотором усилии она сложится. Однако, сложив из стержней треугольник, конструкция сложится, только если сломать один из стержней.

Ферменная конструкция состоит из таких треугольников. Поскольку стержни лучше работают на сжатие-растяжение, чем на излом, то нагрузка к ферме прикладывается в точках соединения стержней. Как правило, фермы соединяют между собой жёстко.

Применяются такие конструкции в строительстве для перекрытия больших пролётов. Благодаря этому уменьшается расход и вес материалов, например, при конструировании мостов, систем промышленных зданий, спортивных сооружений.

Классификация ферм:

  • по назначению (опорные конструкции, мостовые, башенные)
    • по материалам изготовления (деревянные, металлические, железобетонные)
      • по работе в пространстве  ( плоские или пространственные)

Плоская ферма воспринимает нагрузки только в одной плоскости — по вертикали, пространственная ферма образует «пространственный брус» и воспринимает нагрузки в любых направлениях. Пространственная ферма состоит из граней в виде плоских ферм, которые крепятся к другим элементам каркаса здания с помощью связей.

  • по типу фермы (ферма Пратта, ферма Уоррена, ферма Больмана) (см рис.1)

Рис.1.Основные типы металлических ферм.

Расчеты таких конструкций с достаточной точностью могут быть вы-

полнены только с использованием высокопроизводительных численных мето-

дов расчета. Для оценки напряженно-деформированного состояния фермы наиболее приемлемы численные методы расчета на основе дискретных расчетных схем, в частности, метод конечных элементов. При этом применение метода конечных элементов позволяет выполнять расчет как статически определимых, так и статически неопределимых ферм на основе единой методики.

1.2.2 Метод прямой жесткости.

Наиболее распространенной реализацией МКЭ является метод прямой жесткости, применяемый для компьютерного моделирования сложных структур. Это матричный метод, который использует жесткость конструкции для вычисления усилий и смещений в узлах.

Жесткость - способность системы сопротивляться появлению упругих деформаций под действием внешних воздействий, она выражается отношением приращения силы к приращению перемещений. Основной характеристикой жёсткости является коэффициент жёсткости. В случаях одномерных деформаций (где справедлив Закон Гука) жёсткость можно определить как произведение модуля упругости  на площадь поперечного сечения.[11]

Система моделируется, как совокупность более простых и идеализированных элементов, соединенных между собой в узлах. Используя матричную математику, составляются уравнения, связывающие узловые смещения и усилия, действующие на структуру. Таким образом, определяется поведение всей структуры.

Метод прямой жесткости возник аэрокосмической отрасли при анализе сложных частей самолета. Метод идеально подходит для компьютерной реализации.

Последовательность действий для реализации метода прямой жесткости

  1. Описать систему координат для конструкции, выбор способа нумерации узлов.
  2. Определить степени свободы для узлов структуры и присвоить им номера.
  3. Разложить ферму на более мелкие части – элементы.

4) Назначить номера элементам структуры.

5) Определить заданные узловые усилия, смещения, граничные условия в терминах перемещений для каждой степени свободы.

6)  Записать уравнения равновесия для каждого элемента в терминах перемещений.

7)  Объединить уравнения равновесия и сформировать  уравнения для всей структуры.

8) Применить граничные условия для исследуемой конструкции и найти неизвестные узловые усилия и перемещения, решив систему.

Расчеты метода можно производить вручную. Это позволяет понять различные процедурные этапы, которые будут рассмотрены, прежде чем перейти к компьютерной реализации. Однако выполнение вычислений таким способом становится невозможным для более сложных систем конечных элементов. В том случае, если исследуемая структура является сложной для выполнения вручную, возможна достаточно простая компьютерная реализация на языке программирования.

1.3 Необходимые технологии и программное обеспечение. Цели и задачи работы. Итоги первой части.

Для реализации поставленной задачи методом конечных элементов

будут использованы следующие программные обеспечения (ПО):

  • MATLAB – ПО и одноименный язык программирования, позволяющий решать прикладные задачи математического моделирования.
  • Android Studio - среда разработки для работы с платформой Android.  Для реализации проектов необходимо использоватьобъектно-ориентированный язык программирования JAVA.

Необходимо, используя метод конечных элементов,

  • Построить алгоритм численного решения трехмерной задачи упругости в Matlab (метод прямой жесткости).
  • Решить оптимизационную задачу нахождения неизвестных параметров МКЭ.
  • Произвести визуализацию исходной фермы, а также фермы, на которую действуют приложенные к узлам усилия в программном обеспечении MATLAB и Android Studio.
  • Подготовить пользовательский интерфейс в вышеуказанных ПО.

В этой главе были рассмотрены история МКЭ, известные  исследователи в этой области и их научные публикации. Продемонстрировано специализированное ПО, направленное на решение задач вышеуказанным методом. Приведено краткое описание МКЭ и метода прямой жесткости, определена их связь между собой. Наконец, определены необходимые средства разработки и поставлены требуемые задачи.

2.  Необходимые алгоритмы реализации метода конечных элементов.

2.1. Теоретические аспекты поставленной задачи.

В этой части проекта будут объяснены этапы применения МКЭ для плоской фермы.

В первой главе было рассмотрено понятие фермы - структуры, состоящей из стержневых элементов с двумя узлами, а также определена связь с методом прямой жесткости. Как правило, ферма состоит из 5 или более треугольных единиц, соединенных узлами, определяющими форму конструкции. Внешние силы работают либо на растяжение, либо на сжатие, действуют только в узлах. Деформируемая система в методе конечных элементов представляет собой множество подобластей - конечных элементов, положение определяется конечным числом степеней свободы. Преимущества такого разделения были рассмотрены в первой главе.

Плоская ферма – ферма, где все элементы и узлы лежат в двумерной плоскости, в отличие от пространственной конструкции с тремя измерениями.

Простейшим структурным элементом в МКЭ является двухузловой или линейный элемент. Существуют также элементы, например с шестью или даже 64 узлами, показанными на рисунке 2. Несмотря на это, в методе прямой жесткости все элементы, независимо от сложности, воспринимаются одинаково.

Рис.2. Типы конечных элементов.

Рассмотрение задачи МКЭ для элементов с двумя узлами имеет большие преимущества:

(А) вычисления могут быть полностью произведены вручную, в отличие от других элементов, представленых выше. Это позволяет понять этапы решения.

(Б) относительно простая реализация метода конечных элементов на компьютере на любом языке программирования.

Сначала рассмотрим математическую модель метода для плоской задачи.

Конструкция, представленная на рис.3., имеет три элемента и три узла с координатамиx иy. Также для каждого элемента задаются необходимые параметры: модуль Юнга,характеризующий сопротивление растяжению или сжатию, площадь поперечного сечения, плотность и длина элемента. Задача рассматривается в декартовой системе координат.

Ключевые элементы метода прямой жесткости – усилия f, действующие на узлы и их перемещенияu, происходящие под действием этих сил. Силы, действующие на координатыx иy узла с номером i, обозначаются  и соответственно. Аналогично происходит обозначение смещений  и . Объединение всех представленных компонентов в вектор представлено ниже, их количество определяет степень свободы системы. В методе прямой жесткости перемещения узлов, определяющих смещение фермы неизвестны.

 ,

Рис.3. Плоская ферменная конструкция с действующими на нее осевыми усилиями.

Для связи этих векторов необходимо сформировать глобальную матрицу жесткостиK для всей ферменной конструкции:

  .

Элементы матрицы – коэффициенты жесткости, имеющие определенный смысл. Например,  представляет силу по оси Y, действующую на узел 1, при которой возникает смещение второго узла по оси X.

Связывающее уравнение в краткой форме представлено формулой (1):

f =K*u (1).

Рассмотрим этапы решения задач методом прямой жесткости более подробно.

Сначала требуется разбить рассматриваемую конструкцию на элементы. Затем вместе с узлами их нужно пронумеровать. Этот процесс очень важен, поскольку влияет на эффективность вычислений, необходимых для получения решения. Использование МКЭ  приводит к системе линейных алгебраических уравнений с большим количеством нулевых коэффициентов. Для плоской задачи все коэффициенты будут лежать между двумя линиями, параллельными главной диагонали матрицы. Расстояние между главной диагональю и этими линиями называется шириной полосы матрицы. Эффективная нумерация приводит к уменьшению размеров требуемой машинной памяти и сокращению времени вычислений. Далее для каждого элемента задается локальной системой координат в виде, где е -  номер элемента. (Рис.4-5)

Рис.4.Разделение на элементы и выбор системы координат

Рис.5.Ферменный элемент с узлами i, j в локальной системе координат.

Из рисунка 5 видно, что элемент плоской ферменной конструкции имеет 4 компонента для узлов и перемещений, то есть 4 степени свободы. Эти компоненты связываются между собой с помощью локальной матрицы жесткости , как показано в полной или краткой формуле  (2):

,

. (2)

Вектора  и  называются узловыми силами и перемещениями для элемента. Разберем построение матрицы .

Из механики материалов следует, что жесткость элемента равна,

где E -  модуль Юнга,A - площадь поперечного сечения,L - длина элемента.

Следовательно, можно записать следующее выражение: , гдеF- внутреннее осевое усилие,d -удлинение. В терминах узловых сил и перемещений: , . В итоге получаем матрицу жесткости в локальной системе координат(3):

(3)

Следующая задача - сформировать из локальных матриц глобальную матрицу жесткости. Так как каждый элемент имеет свою собственную систему координат, то необходимо использовать матрицы поворотаT и  (транспонированная матрица T) для перемещений и усилий соответственно, чтобы привести все системы к общему виду (рис.4.) .

где с =cos, s = sin.

Рис.4. Поворот элемента на угол  в декартовой системе координат.

Пусть е – индекс элемента. Запишем формулу (1) с учетом этого номера:

Также перепишем формулы для вышеуказанных матриц поворота.

,

Используя формулу(2), получаем

Итак,

,  (4)

где

Формула(4) определяет глобальную матрицу жесткости для элемента.

Следующий этап – объединение уравнений для каждого элемента  в одну  глобальную систему. Здесь необходимо учесть два правила:

  1. объединенные узлы должны двигаться, как единое целое
  2. сумма внутренних сил, действующих со стороны всех элементов, которые имеют общий узел, равна внешний силе, действующей на тот же узел.

После этого для каждого элемента к матрице, представленной в формуле(4), добавляются строки и столбцы с нулевыми элементами. Номера добавленных строк и столбцов соответствуют номерам узлов, не принадлежащих этим элементам. Такой способ применяется для ручной работы, на компьютере он является неэффективным из-за большого выделения памяти.

Получив уравнениядля элементов, i определяет номер элемента, записывается общее уравнение для всей ферменной конструкции.

,

где N – количество элементов.

Поскольку матрица является сингулярной, то для решения уравнений необходимо применить граничные условия. В ручном методе проще всего удалить уравнения, соответствующие нулевым перемещениям. Для компьютерной реализации расширение матрицы не происходит. Она вставляется в свободную таблицу для элементов. Для нулевых перемещений зануляются строки и столбцы, соответствующие нулевым перемещениям и силам и устанавливаются единицы на диагоналях для убирания сингулярности. Если  узловое перемещение ненулевое, то исходная система (5) преобразуется в (6). Таким образом, получаем итоговую систему линейных алгебраических уравнений.

(5)

(6)

Завершающий этап вычисления неизвестных перемещений заключается в решении  системы. Существует большое множество способом: матричный метод, метод итерации, прогонки и др. Однако метод Гаусса является самым наглядным и простым из всех вариантов. В дальнейшем, именно он будет использоваться для реализации МКЭ.

В пространственной задаче метода прямой жесткости алгоритм действия аналогичен за небольшим исключением: матрица поворота записывается в виде:

,

где

,,,

а глобальная матрица жесткости:

[13][14][15][16][17].

2.2 Программирование подAndroid.

Рассмотрим особенности программирования подAndroid.Класс Activity - самый важный класс, из которого строится приложение Android. Этот класс представляет визуальную активность приложения, и определяет действия, которые может производить пользователь. Почти все экземпляры и разновидности activitу напрямую взаимодействуют с пользователем, так что класс Activity отвечает за создание окна, в котором можете разместить свой визуальный интерфейс

 Для передачи данных между activity существует intent – это объект, в котором мы прописываем, какое Activity нам необходимо вызвать. После чего мы передаем этот Intent-объект методу startActivity, который находит соответствующее Activity и показывает его.

Для получения доступа к виджетам, используется метод findViewById(int).Для реагирования кнопок на нажатие используется метод setOnClickListener (View.OnClickListener l). На вход подается объект с интерфейсом View.OnClickListener. 

Компонент TextView предназначен для отображения текста без возможности редактирования его пользователем, что видно из его названия. Программно он задается с помощью метода setText().

Компонент EditText — это текстовое поле для пользовательского ввода, которое используется, если необходимо редактирование текста. Следует заметить, что EditText является наследником TextView.

Виджет ListView представляет собой прокручиваемый список элементов. Компонент ListView более сложен в применении по сравнению с TextView и другим простыми элементами. Работа со списком состоит из двух частей. Сначала мы добавляем на форму сам ListView, а затем заполняем его элементами списка. Компоненту ListView требуются данные для наполнения. Источником наполнения могут быть массивы, базы данных. Чтобы связать данные со списком, используется так называемый адаптер. Метод setAdapter(ListAdapter) связывает подготовленный список с адаптером.

3 Результаты исследования.

Для решения трехмерной задачи упругости с помощью метода конечных элементов были заданы следующие основные параметры:

  1. Количество секций.
  2. Высота, длина и ширина секций.
  3. Свойства материала.
  4. Основная нагрузка, приходящаяся на нижние узлы фермы.
  5. Площадь поперечного сечения элемента.

Были поставлены следующие задачи: первое задание - поиск максимальной полезной нагрузки, которую ферма способна выдержать с учетом запаса прочности. Второе задание - поиск минимальной площади поперечного сечения элемента, при которой ферма способна выдержать заданную нагрузку. Третье задание - поиск максимальной длины секции, при которой ферма способна выдержать заданную нагрузку.

Для фермыПратта были сгенерированы узлы и соединяющие их элементы, заданы усилия и граничные условия. Затем была получена локальная и глобальная матрица жесткости для каждого элемента и всей конструкции соответственно. После учитывания граничных условий и решения системы линейных алгебраических уравнений были получены неизвестные параметры, на основе которых получилась смещенная конструкция под действием заданных усилий.

После определения координат смещенных узлов было вычислено механическое напряжение, действующее на каждый элемент конструкции. Это мера внутренних сил, возникающих в деформируемом теле, являющаяся результатом взаимодействия частиц тела при его нагружении. Внешние силы стремятся изменить взаимное расположение частиц, а возникающие при этом напряжения препятствуют смещению частиц.

Если напряжение превышало критическое значение, то ферма не выдерживала нагрузку. Напряжение вычислялось, как произведение деформации на модуль Юнга.

Также  использовался пользовательский интерфейс в виде диалоговых окон.

Используя теоретические аспекты, рассмотренные в этой главе, МКЭ был реализован в ПО MATLAB, для наилучшего представления метода, после чего был перенесен на платформу Android. Диалоговые окна, визулизация и решение системы уравнений выполнены преимущественно с помощью стандартных библиотек.

В Android Studio вышеуказанные компоненты разрабатывались вручную. Для решения уравней использовался метод Гаусса. А отрисовка результата моделирования фермы в среде Android Studio прооисходила с помощью специального объекта – canvas (канва).Через наследника View класса, переопределив его метод onDraw,был получен доступ к канве.  Реализация этого способа достаточно проста, но имеет один недостаток – рисование происходит в основном потоке.

Существует также другой способ, через метод surfaceView. Преимущества этого метода в том, что он позволяет  отрисовывать динамические объекты, однако он сложнее в реализации.

3.1  Реализация метода конечных элементов на языке программированияMATLAB.

С помощью диалоговых окон были отображены задания, их выбор, поля для ввода входных данных, заполняемые по умолчанию, полученный результат и визуализация решения. (Рисунок 5-8)

Рис.5. Определение заданий.

Рис.6.Выбор номера задания.

Рис.7. Заполнение данных.

Рис.8.Полученный ответ.

На рисунке 9 показана визуализация фермы Пратта для представленных выше входных данных. Отображены номера узлов и элементов.

Рис.9.Ферма Пратта с указанными номерами узлов и элементов.

В последнем окне (рисунок 10) отображены конструкции до и после применения усилий, тип граничных условий (левая  часть полностью фиксирована, правая может перемещаться вдоль оси X), вектора сил, а также максимальное и минимальное напряжение.

Рис.10.Ферма Пратта до и после применения усилий на нижние узлы.

3.2 Реализация метода конечных элементов на языке программированияJAVA под ОСAndroid.

На основе теории, представленной в главе 2.2, были получены результаты программы, представленной на рисунках 11-14.

Рис.11-13. Выбор и определение заданий.

Рис.14.Входные данные и результат.

Рис.15. Визуализация.

При анализе значений в Android и MATLAB была выявлена погрешность около 1%, что подтверждают вышеуказанные рисунки.

Итак, был подробно рссмотрен алгоритм решение задачи МКЭ. Приведены результаты в программном обеспечении MATLAB и Android Studio. Погрешность данных составила около 1%.

Заключение

На основе двухмерной задачи упругости методом прямой жесткости была произведена реализация трехмерного случая в программном обеспеченииMATLAB иAndroidStudio. С помощью заданных усилий и вычисленной глобальной матрицы жесткости были получены перемещения каждого узла конструкции. В результате произведенного моделирования получена смещенная конструкция под действием приложенных сил. Погрешность полученных результатов - 1%.

Рассмотрены способы отображения графических объектов в Android Studio, их преимущества и недостатки.

Полученное программное обеспечение может быть использовано для моделирования фермы Пратта с различными входными данными.

7.​ Список изученной литературы.

[1]http://www.mmf.spbstu.ru/zenit/(30.05.2016)

[2] Reddy, J.N,An Introduction to the Finite Element Method.

[3]Hastings, J. K., Juds, M. A., Brauer, J. R., Accuracy and Economy of Finite Element Magnetic Analysis.

[4]Peng Long; Wang Jinliang; Zhu Qiding, Methods with high accuracy for finite element probability computing.

[5] Haldar, Achintya; Mahadevan, Sankara, ReliabilityAssessment Using Stochastic Finite Element Analysis. John Wiley & Sons.

[6] http://www.nasa.gov/centers/dryden/news/X-Press/stories/2008/10_08_technology.html(30.05.2016)

 [7]Strang, Gilbert; Fix, George (1973). An Analysis of The Finite Element Method. Prentice Hall. ISBN 0-13-032946-0.

[8]http://lib.rgsu.ru/MegaPro/Download/MObject/220/1179F.pdf(30.05.2016)

[9]https://en.wikipedia.org/wiki/Finite_element_method(30.05.2016)

[10]http://meh.samgtu.ru/sites/meh.samgtu.ru/files/fokin.pdf(30.05.2016)

[11]http://konstruirovanie-mashin.ru/glava-ratsionalnoe-konstruirovanie-izdelii/zhestkost-konstruktsii(30.05.2016)

[12] Дарков А.В. Строительная механика. (30.05.2016)

[13]http://people.duke.edu/~hpgavin/cee421/truss-3d.pdf

[14]https://engineering.purdue.edu/~aprakas/CE474/CE474-Ch5-StiffnessMethod.pdf(30.05.2016)

[15]http://www.colorado.edu/engineering/CAS/courses.d/IFEM.d/IFEM.Ch02.d/IF[16]EM.Ch02.pdf(30.05.2016)

[17]http://www.colorado.edu/engineering/CAS/courses.d/IFEM.d/IFEM.Ch03.d/IFEM.Ch03.pdf(30.05.2016)

[18]http://startandroid.ru/ru/uroki/vse-uroki-spiskom/311-urok-1-risovanie-dostup-k-canvas.html(30.05.2016)

                                                            Приложение 1. Программа на языке MATLAB.

Main.m;

close all;

%-----------------------------------Входные параметры

%sectNum - кол-во секций в трехмерной системе

%k - кол-во узлов в трехмерной системе

%H - высота

%W - ширина

%scale - масш.коэф. смещений

%ro - плотность

%modY- модуль юнга(упругости)

%P -  полезная нагрузка приходящаяся на каждый нагруженный узел.

%sigmaT - предел прочности при растяжении

%K - коэф.запаса прочности

%Krit - критическое значение, если напряжение в материале превышает это значение, то материал разрушается

g = 9.81;

ro = 7800;

modY = 210 * 10^9;

sigmaT = 600 * 10^6;

K = 2;

Krit = sigmaT/K;

h = msgbox({'Первое задание - поиск максимальной полезной нагрузки, которую ферма способна выдержать с учетом запаса прочности.' 'Второе задание - поиск минимальной площади поперечного сечения элемента, при которой ферма способна выдержать заданную нагрузку.' 'Третье задание - поиск максимальной длины секции, при которой ферма способна выдержать заданную нагрузку.' } , 'Задание');

[Selection,ok] = listdlg('ListString', {'1'; '2'; '3'},'Name', 'Выберите номер задания','ListSize', [300 90],'SelectionMode','single') ;

switch Selection

   case 1

       outPar=inputdlg({'Количествосекций(6,10,14...)''Высота(м)' 'Ширина(м)' 'Длина(м)' 'Площадь поперечного сечения (м^2)' 'Масштабирующий коэффициент смещения узлов'},'Input Data',1,{'14','2','1','3','0.01','1'});

sectNum = str2double(outPar{1});

       H = str2double(outPar{2});

       W = str2double(outPar{3});

       L = str2double(outPar{4});

       A = str2double(outPar{5});

       scale = str2double(outPar{6});

       k = 2*sectNum +4;

       trussGen(k, H, L, W,modY,ro);

       forceGen(k, H, L,W, A, ro, g);

       forces = load('Forces.txt', '-ascii');

       P = fminbnd(@(P)minS(Selection,P, k, H, L,W,A, ro, g, Krit,modY), 0, 5000000);

msg = {'Максимальная полезная нагрузка(кг):',num2str(P)};

       outVar = msgbox(msg, 'Ответ');

   case 2

       outPar=inputdlg({'Количество секций(6,10,14...)' 'Высота(м)' 'Ширина(м)' 'Длина(м)' 'Полезная нагрузка(кг)' 'Масштабирующий коэффициент смещения узлов'}, 'Input Data',1,{'14','2','1','3','25000','1'});

sectNum = str2double(outPar{1});

       H = str2double(outPar{2});

W = str2double(outPar{3});

       L = str2double(outPar{4});

       P = str2double(outPar{5});

       scale = str2double(outPar{6});

       k = 2*sectNum +4;

       trussGen(k, H, L, W,modY,ro);

       A = fminbnd(@(A)minS(Selection,P, k, H, L,W,A, ro, g, Krit,modY), 0, 5000);

msg = {'Минимальная площадь поперечного сечения(м^2):',num2str(A)};

outVar = msgbox(msg, 'Ответ');

       forceGen(k, H, L,W, A, ro, g);

       forces = load('Forces.txt', '-ascii');

   case 3

       outPar=inputdlg({'Количествосекций(6,10,14...)''Высота(м)' 'Ширина(м)' 'Полезная нагрузка(кг)' 'Площадь поперечного сечения(м^2)' 'Масштабирующий коэффициент смещения узлов'}, 'Input Data',1,{'14','2','1','25000','0.01','1'});

sectNum = str2double(outPar{1});

       H = str2double(outPar{2});

       W = str2double(outPar{3});

       P = str2double(outPar{4});

       A = str2double(outPar{5});

       scale = str2double(outPar{6});

       k = 2*sectNum +4;

       L = fminbnd(@(L)minS(Selection,P, k, H, L,W,A, ro, g, Krit,modY), 1, 100);

msg = {'Максимальная длина секции(м):',num2str(L)};

       outVar = msgbox(msg, 'Ответ');

       trussGen(k, H, L, W,modY,ro);

forceGen(k, H, L,W, A, ro, g);

       forces = load('Forces.txt', '-ascii');

otherwise

       break;

end

Nodesload = load('nodes.txt','-ascii');

nodes = reshape(Nodesload',1,k*3);

elements= load('elements.txt', '-ascii');

s = size(elements);

N1 = s(1);

s = size(forces);

f = reshape(forces', 1, s(1)*s(2));

s = size(f);

for i = 1:1:s(2)

   if mod(i, 6) == 0

       f(i) = f(i) - P*g;

   end;

end;

[u] = trussDisplace(elements, f, nodes, A, modY, k, N1);

u = scale*u;

nodesnew=nodes+u';

firstFig(elements, Nodesload, k , L);

secondFig(nodes,nodesnew,elements, L, k, N1, P,modY);

minS.m

function [ a ] = minS(Var,P, k , h, len,wid, AA, ro, g, Krit,modY)

if Var == 2

forceGen(k , h, len,wid, AA, ro, g);

end;

if Var == 3

trussGen(k, h, len, wid,modY,ro);

forceGen(k , h, len,wid, AA, ro, g);

end;

display(len)

forces = load('Forces.txt', '-ascii');

s=size(forces);

f=reshape(forces', 1, s(1)*s(2));

s = size(f);

for i = 1:1:s(2)

   if mod(i, 6) == 0

       f(i) = f(i) - P*g;

   end;

end;

Nodes = load('nodes.txt','-ascii');

Elementsload = load('elements.txt', '-ascii');

s = size(Nodes);

N=s(1);

nodes = reshape(Nodes',1,s(1)*3);

elements=Elementsload(:,[1 2]);

s=size(elements);

N1=s(1);

[u] = trussDisplace(elements, f, nodes, AA, modY, N, N1);

nodesnew=nodes+u';

epsilon = zeros(1,N1);

sigma = zeros(1,N1);

for i = 1:1:N1

   xi1=nodes(elements(i,1)*3-2);

   yi1=nodes(elements(i,1)*3-1);

zi1=nodes(elements(i,1)*3);

   xj1=nodes(elements(i,2)*3-2);

   yj1=nodes(elements(i,2)*3-1);

   zj1=nodes(elements(i,2)*3);

   xi2=nodesnew(elements(i,1)*3-2);

   yi2=nodesnew(elements(i,1)*3-1);

   zi2=nodesnew(elements(i,1)*3);

   xj2=nodesnew(elements(i,2)*3-2);

   yj2=nodesnew(elements(i,2)*3-1);

   zj2=nodesnew(elements(i,2)*3);

   L1 = sqrt((xi1 - xj1)^2 + (yi1 - yj1)^2 + (zi1 - zj1)^2);

   L2 = sqrt((xi2 - xj2)^2 + (yi2 - yj2)^2+ (zi2 - zj2)^2);

   epsilon(i) = (L2 - L1)/L1;

   sigma(i) = modY * epsilon(i);

end;

t = max(abs(sigma));display(t);

a = abs(t - Krit);

end

function [ a ] = minS(Var,P, k , h, len,wid, AA, ro, g, Krit,modY)

if Var == 2

forceGen(k , h, len,wid, AA, ro, g);

end;

if Var == 3

trussGen(k, h, len, wid,modY,ro);

forceGen(k , h, len,wid, AA, ro, g);

end;

display(len)

forces = load('Forces.txt', '-ascii');

s=size(forces);

f=reshape(forces', 1, s(1)*s(2));

s = size(f);

for i = 1:1:s(2)

   if mod(i, 6) == 0

       f(i) = f(i) - P*g;

   end;

end;

Nodes = load('nodes.txt','-ascii');

Elementsload = load('elements.txt', '-ascii');

s = size(Nodes);

N=s(1);

nodes = reshape(Nodes',1,s(1)*3);

elements=Elementsload(:,[1 2]);

s=size(elements);

N1=s(1);

[u] = trussDisplace(elements, f, nodes, AA, modY, N, N1);

nodesnew=nodes+u';

epsilon = zeros(1,N1);

sigma = zeros(1,N1);

for i = 1:1:N1

   xi1=nodes(elements(i,1)*3-2);

   yi1=nodes(elements(i,1)*3-1);

   zi1=nodes(elements(i,1)*3);

   xj1=nodes(elements(i,2)*3-2);

yj1=nodes(elements(i,2)*3-1);

   zj1=nodes(elements(i,2)*3);

   xi2=nodesnew(elements(i,1)*3-2);

   yi2=nodesnew(elements(i,1)*3-1);

   zi2=nodesnew(elements(i,1)*3);

   xj2=nodesnew(elements(i,2)*3-2);

   yj2=nodesnew(elements(i,2)*3-1);

   zj2=nodesnew(elements(i,2)*3);

   L1 = sqrt((xi1 - xj1)^2 + (yi1 - yj1)^2 + (zi1 - zj1)^2);

   L2 = sqrt((xi2 - xj2)^2 + (yi2 - yj2)^2+ (zi2 - zj2)^2);

   epsilon(i) = (L2 - L1)/L1;

   sigma(i) = modY * epsilon(i);

end;

t = max(abs(sigma));display(t);

a = abs(t - Krit);

end

trussGen.m

function [  ] = trussGen(k, H, L,W, modY, ro)

%-------------Генерация узлов

X = zeros(k,3);

X(1,:) = 0;

X(2:2:k/2,1) = L:L:k/4*L;

X(3:2:k/2-1,1) = L:L:(k/4-1)*L;

X(2:1:k/2,2) = 0;

X(2:2:k/2,3) = 0;

X(3:2:k/2,3) = H;

X(k/2 + 1,1:3) = [0 W 0];

X(k/2+1:k,1) = X(1:k/2,1);

X(k/2+1:k,2) = W;

X(k/2+2:k,3) = X(2:1:k/2,3);

dlmwrite('nodes.txt',X)

%-----Генерация элементов

for i = 1:1:k/4-1

Y(2*i -1,1) = i;

    Y(2*i -1,2) = i + 1;

    Y(2*i,1) = i;

    Y(2*i,2) = i + 2;

end;

for i = k/4:2:k/2-4

Y(2*i -1,1) = i;

    Y(2*i -1,2) = i + 1;

    Y(2*i +1,1) = i;

    Y(2*i +1,2) = i + 3;

    Y(2*i,1) = i;

    Y(2*i,2) = i + 2;

end;

for i = k/4+1:2:k/2-3

Y(2*i,1) = i;

    Y(2*i,2) = i + 2;

end;

for i = k/2-2

Y(2*i,1) = i;

    Y(2*i,2) = i + 2;

    Y(2*i -1,1) = i;

    Y(2*i -1,2) = i + 1;

end;

for i=k/2-1

    Y(2*i -1,1) = i;

Y(2*i -1,2) = i + 1;

end;

for i = k/2+1:1:3*k/4-1

Y(2*i -4,1) = i;

    Y(2*i -4,2) = i + 1;

    Y(2*i-3,1) = i;

    Y(2*i-3,2) = i + 2;

end;

for i = 3*k/4:2:k-4

Y(2*i -4,1) = i;

    Y(2*i -4,2) = i + 1;

    Y(2*i -2,1) = i;

    Y(2*i -2,2) = i + 3;

    Y(2*i-3,1) = i;

    Y(2*i-3,2) = i + 2;

end;

for i = 3*k/4+1:2:k-3

Y(2*i-3,1) = i;

    Y(2*i-3,2) = i + 2;

end;

for i = k - 2

Y(2*i-3,1) = i;

    Y(2*i-3,2) = i + 2;

    Y(2*i -4,1) = i;

    Y(2*i -4,2) = i + 1;

end;

for i=k-1     Y(2*i -4,1) = i;

    Y(2*i -4,2) = i + 1;

end;

for i = 1:1:k/2

    Y(2*k-6+i,1) = i;

    Y(2*k-6+i,2) = i + k/2;

end;

for i = 1:1:k/2-2

    if i == 1

    Y(2*k+i+(k/2-6),1) = i;

    Y(2*k+i+(k/2-6),2) = i +1+ k/2;

    else

    Y(2*k+i+(k/2-6),1) = i;

    Y(2*k+i+(k/2-6),2) = i +2+ k/2;

    end;

end;

Y(2*k+k-7,1) = 2;

Y(2*k+k-7,2) = 1+ k/2;

for i = 4:1:k/2

Y(3*k+i-10,1) = i;

    Y(3*k+i-10,2) = i- 2 + k/2;

end;

Y(7*k/2-9,1) = 1;

Y(7*k/2-9,2) = k/2+3;

Y(7*k/2-8,1) = k/2;

Y(7*k/2-8,2) = k-1;

j=1;

for i = 3:2:k/2-1

   Y(7*k/2-8+j,1) = i;

   Y(7*k/2-8+j,2) = k/2-1+i;

   j=j+1;

end;

dlmwrite('elements.txt',Y)

trussDispalce.m

function [u] = trussDisplace( elements, f, nodes,A, E, k, N1)

K = zeros(k*3, k*3);

for i = 1:1:N1;

   xi = nodes(elements(i,1)*3-2);

   yi = nodes(elements(i,1)*3-1);

   zi = nodes(elements(i,1)*3);

   xj = nodes(elements(i,2)*3-2);

   yj = nodes(elements(i,2)*3-1);

   zj = nodes(elements(i,2)*3);

   dx = xj-xi;

   dy = yj-yi;

   dz = zj-zi;

   l = sqrt( dx*dx+dy*dy+dz*dz);

   cx = dx / l;

   cy = dy / l;

   cz = dz / l;

   T = [cx cy cz 0 0 0; 0 0 0 cx cy cz];

   Ke = (E * A / l) .* (T' * [1 -1; -1 1] * T);

   K([elements(i,1)*3-2 elements(i,1)*3-1 elements(i,1)*3 elements(i,2)*3-2 elements(i,2)*3-1 elements(i,2)*3],...

     [elements(i,1)*3-2 elements(i,1)*3-1 elements(i,1)*3 elements(i,2)*3-2 elements(i,2)*3-1 elements(i,2)*3])=...

   K([elements(i,1)*3-2 elements(i,1)*3-1 elements(i,1)*3 elements(i,2)*3-2 elements(i,2)*3-1 elements(i,2)*3],...

     [elements(i,1)*3-2 elements(i,1)*3-1 elements(i,1)*3 elements(i,2)*3-2 elements(i,2)*3-1 elements(i,2)*3])+Ke;

end;

ux(1,:) = [1 0];

uy(1,:) = [1,0];

uz(1,:) = [1,0];

uy(2,:) =[k/2, 0];

uz(2,:) = [k/2,0];

ux(2,:) = [k/2+1 0];

uy(3,:) = [k/2+1,0];

uz(3,:) = [k/2+1,0];

uy(4,:) =[k,0];

uz(4,:) =[k,0];

f(ux(:,1)*3-2)= ux(:,2);

f(uy(:,1)*3-1)= uy(:,2);

f(uz(:,1)*3)  = uz(:,2);

m = vertcat(ux(:,1)*3-2,uy(:,1)*3-1,uz(:,1)*3);

s = size(m);

K(m,:) = zeros(3*k,s(1))';

K(:,m) = zeros(3*k,s(1));

e(1:s(1),1) = 1;

K((m(:)-1)*k*3+m(:)) = e;

u = zeros(3*k,1);

u = K\f';

end

SecondFig.m

function [  ] = secondFig( nodes,nodesnew, elements, L,N, N1, P,modY )

figure;

hold on;

grid on;

xlabel('x');

ylabel('y');

zlabel('z');

colormap jet;

colorbar;

epsilon = zeros(1,N1);

for i = 1:1:N1

   xi1(i)=nodes(elements(i,1)*3-2);

   yi1(i)=nodes(elements(i,1)*3-1);

   zi1(i)=nodes(elements(i,1)*3);

   xj1(i)=nodes(elements(i,2)*3-2);

   yj1(i)=nodes(elements(i,2)*3-1);

   zj1(i)=nodes(elements(i,2)*3);

   plot3([xi1(i) xj1(i)], [yi1(i) yj1(i)],[zi1(i) zj1(i)],'Color',[0.5 0.9 0.9]);

   xi2(i)=nodesnew(elements(i,1)*3-2);

   yi2(i)=nodesnew(elements(i,1)*3-1);

   zi2(i)=nodesnew(elements(i,1)*3);

   xj2(i)=nodesnew(elements(i,2)*3-2);

   yj2(i)=nodesnew(elements(i,2)*3-1);

   zj2(i)=nodesnew(elements(i,2)*3);

   L1 = sqrt((xi1(i) - xj1(i))^2 + (yi1(i) - yj1(i))^2 + (zi1(i) - zj1(i))^2);

   L2 = sqrt((xi2(i) - xj2(i))^2 + (yi2(i) - yj2(i))^2+(zi2(i) - zj2(i))^2);

   epsilon(i) = (L2 - L1)/L1;

   stress(i)= modY*epsilon(i);

   patch([xi1(i) xj1(i)], [yi1(i) yj1(i)],[zi1(i) zj1(i)], [stress(i) stress(i)], 'EdgeColor', 'flat', 'LineWidth', 2);

end;

minX = min(nodes(1));

maxX = max(nodes(3*N-2));

minY = min(yi1(i),yj1(i));

maxY = max(yi1(i),yj1(i));

minZ = min(zi1(i),zj1(i));

maxZ = max(zi1(i),zj1(i));

axis([minX - 1 maxX + 1 minY - 1 maxY + 1 minZ - 1 maxZ + 1])

[~, mini] = min(epsilon);

[~, maxi] = max(epsilon);display(xi1(i))

for i=1:1:N1

   plot3([xi2(i) xj2(i)], [yi2(i) yj2(i)],[zi2(i) zj2(i)],'r');

end;

text((xi2(maxi)+xj2(maxi))/2 ,(yi2(maxi)+yj2(maxi))/2,(zi2(maxi)+zj2(maxi))/2, num2str(epsilon(maxi)), 'FontSize',12);

text((xi2(mini)+xj2(mini))/2 ,(yi2(mini)+yj2(mini))/2,(zi2(mini)+zj2(mini))/2, num2str(epsilon(mini)), 'FontSize',12);

plot3(nodesnew(46), nodesnew(47),nodesnew(48),'<');

plot3(nodesnew(25), nodesnew(26),nodesnew(27),'^');

plot3(nodesnew(1), nodesnew(2),nodesnew(3), '^');

plot3(nodesnew(22), nodesnew(23),nodesnew(24), '<');

for i=4:6:3*N/2-4

    quiver3(nodesnew(i), nodesnew(i+1),nodesnew(i+2), 0,0, -P/4, 5e-5, 'b');

end;

for i=3*N/2+4:6:3*N-5

    quiver3(nodesnew(i), nodesnew(i+1),nodesnew(i+2), 0,0, -P/4, 5e-5, 'b');

end;

daspect([1 1 1]);

view([-1 -1 1]);

end

forceGen.m

function [] = forceGen(k, H, L,W, A, ro, g)

HL = sqrt(H^2 + L^2);

WL = sqrt(W^2 + L^2);

HWL = sqrt(H^2 + WL^2);

WH = sqrt(H^2 + W^2);

V1 = H * A;

V2 = L * A;

V3 = HL * A;

V4 = W * A;

V5 = WL*A;

V6 = HWL*A;

V7 = WH*A;

m1 = V1 * ro;

m2 = V2 * ro;

m3 = V3 * ro;

m4 = V4*ro;

m5 = V5*ro;

m6 = V6*ro;

m7 = V7*ro;

F1  = m1 * g / 2;

F2 =  m2 * g / 2;

F3 =  m3 * g / 2;

F4 =  m4* g / 2;

F5 =  m5* g / 2;

F6 =  m6* g / 2;

F7 =  m7* g / 2;

forces(1, :) = [0 0 -(F2+F3+F4+F5+F6)];

forces(2, :) = [0 0 -(2*F2+F1+F4+2*F5)];

forces(3, :) = [0 0 -(F1+F2+2*F3+F4+F5+F7)];

if k ~= 16

for i = 4:2:(k/4) -2

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5)];

end;

end;

if k ~= 16

for i = 5:2:(k/4) - 1

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5+F7)];

end;

end;

forces(k/4, :)   = [0 0 -(F1+2*F2+2*F3+F4+2*F5)];

forces(k/4 + 1, :)   = [0 0 -(F1+2*F2+F4+2*F5+F7)];

if k ~= 16

for i = k/4 + 2:2:k/2 -4

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5)];

end;

end;

if k ~= 16

for i = k/4 + 3:2:k/2 -3

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5+F7)];

end;

end;

forces(k/2-2, :) = [0 0 -(F1+2*F2+F4+2*F5)];

forces(k/2-1, :) = [0 0 -(F1+F2+2*F3+F4+F5+F7)];

forces(k/2, :) =   [0 0 -(F2+F3+F4+F5+F6)];

forces(k/2+1, :) = [0 0 -(F2+F3+F4+F5)];

forces(k/2+2, :) = [0 0 -(F1+2*F2+F4+2*F5+F7)];

forces(k/2+3, :) = [0 0 -(F1+F2+2*F3+F4+F5+F6)];

if k ~= 16

for i = k/2+4:2:(3*k/4) -2

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5+F7)];

end;

end;

if k ~= 16

for i = k/2+5:2:(3*k/4) -1

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5)];

end;

end;

forces(3*k/4, :)   = [0 0 -(F1+2*F2+2*F3+F4+2*F5+F7)];

forces(3*k/4 + 1, :)   = [0 0 -(F1+2*F2+F4+2*F5)];

if k ~= 16

for i = 3*k/4 + 2:2:k -4

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5+F7)];

end;

end;

if k ~= 16

for i = 3*k/4 + 3:2:k -3

   forces(i, :) = [0 0 -(F1+2*F2+F3+F4+2*F5)];

end;

end;

forces(k-2, :) = [0 0 -(F1+2*F2+F4+2*F5+F7)];

forces(k-1, :) = [0 0 -(F1+F2+2*F3+F4+F5+F6)];

forces(k, :) = [0 0 -(F2+F3+F4+F5)];

dlmwrite('Forces.txt',forces);

end

firstFig.m

function [ ] = firstFig(  Elementsload, Nodes, k , L)

figure;

hold on;

grid on;

xlabel('x');

ylabel('y');

zlabel('z');

minX = min(Nodes(:, 1));

maxX = max(Nodes(:, 1));

minY = min(Nodes(:, 2));

maxY = max(Nodes(:, 2));

minZ = min(Nodes(:, 3));

maxZ = max(Nodes(:, 3));

axis([minX - 1 maxX + 1 minY - 1 maxY + 1 minZ - 1 maxZ + 1])

sE = size(Elementsload);

sN = size(Nodes);

for i = 1:1:sN

   x = Nodes(i, 1);

   y = Nodes(i, 2);

   z = Nodes(i, 3);

   plot3(x,y,z, '.r', 'MarkerSize', 14);

   text(x, y,z,strcat(' ', int2str(i)), 'color', [0 0 1]);

end;

for i = 1:1:sE

   ni = Elementsload(i, 1);

   nj = Elementsload(i, 2);

   xi = Nodes(ni, 1);

   xj = Nodes(nj, 1);

   yi = Nodes(ni, 2);

   yj = Nodes(nj, 2);

   zi = Nodes(ni, 3);

   zj = Nodes(nj, 3);

   plot3([xi xj], [yi yj],[zi zj]);

   text((xi + xj)/2, (yi + yj)/2,(zi + zj)/2,strcat(' ', int2str(i)));

end;

daspect([1 1 1]);

view([-1 -1 1]);

end

Приложение 2. Программа на языке JAVA вAndroidStudio.

MainActivity.java

package ru.hse.android.diplom;

import android.app.DialogFragment;

import android.content.Intent;

import android.os.Bundle;

import android.support.v7.app.ActionBarActivity;

import android.view.View;

import android.widget.Button;

public class MainActivity extends ActionBarActivity implements  View.OnClickListener{

Button btnDlg1;

   DialogFragment dlg2;

   @Override

   public void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);

       setContentView(R.layout.activity_main);

       dlg2 = new Task();

      btnDlg1 = (Button) findViewById(R.id.btnDlg1);

      btnDlg1.setOnClickListener (this);

   }

   public void onClick(View v) {

       switch (v.getId()) {

           case R.id.btnDlg1:

               Intent intent = new Intent(this,Choice.class);

               startActivity(intent);

               break;

           case R.id.btnDlg2:

               dlg2.show(getFragmentManager(), "dlg2");

               break;

           default:

               break;

       }

   }

}

Choice.java

package ru.hse.android.diplom;

import android.content.Context;

import android.content.Intent;

import android.os.Bundle;

import android.support.v7.app.ActionBarActivity;

import android.widget.AdapterView;

import android.widget.ArrayAdapter;

import android.widget.ListView;

import android.view.View;

public class Choice extends ActionBarActivity {

// элементы списка которые будут в него внесены

String[]colors = {"Первое", "Второе", "Третье"};

@Override

   public void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);

       setContentView(R.layout.choice);

       // Связываемся с ListView

       ListView list = (ListView) findViewById(R.id.lvMain);

       // создаем адаптер

       final ArrayAdapter<String> adapter = new ArrayAdapter<String>

               (this, android.R.layout.simple_list_item_1, colors);

       // устанавливаем адаптер списку

       list.setAdapter(adapter);

           list.setOnItemClickListener(new AdapterView.OnItemClickListener() {

            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

                Context context = getApplicationContext();

                Intent intent = new Intent(context, Input.class);

                intent.putExtra("id", id+1);

                startActivity(intent);

                                          }

              });

   }

}

Displacements.java

package ru.hse.android.diplom;

public class Displacements {

   static double[] findDisp(int kUzl,int[][] elements,double[] nodes,double crossSectionArea, double modY,double[] forces,double P)

   {

       double[] applyGravity  = Forces.applyP(forces,kUzl,P);

       double[][]K = StiffnessMatrix.modifyK(kUzl,elements, nodes,crossSectionArea,modY,applyGravity);

       double[][] slauMatrix = new double[3*kUzl][3*kUzl+1];

       for (int i = 0;i<3*kUzl;i++) {

           for (int j = 0;j<3*kUzl;j++) {

               slauMatrix[i][j] = K[i][j];

           }

       }

       double[][] reshapeForcesColumn = new double[3*kUzl][1];

       for (int i = 0;i<3*kUzl;i++) {

           reshapeForcesColumn[i][0] = applyGravity[i];

           slauMatrix[i][3*kUzl] = slauMatrix[i][3*kUzl]+ reshapeForcesColumn[i][0];

       }

       double x[] = new double[slauMatrix.length];

       for (int i = 0; i < x.length; i++) {

           x[i] = slauMatrix[i][slauMatrix[i].length - 1];

       }

       double n;

       for (int k = 1; k < slauMatrix.length; k++) {

           for (int j = k; j < slauMatrix.length; j++) {

               n = slauMatrix[j][k - 1] / slauMatrix[k - 1][k - 1];

               for (int i = 0; i < slauMatrix[j].length; i++) {

                   slauMatrix[j][i] = slauMatrix[j][i] - n * slauMatrix[k - 1][i];

               }

               x[j] = x[j] - n * x[k - 1];

           }

       }

       for (int i = slauMatrix.length - 1; i >= 0; i--) {

           for (int j = i + 1; j < slauMatrix.length; j++) x[i] -= slauMatrix[i][j] * x[j];

           x[i] = x[i] / slauMatrix[i][i];

       }

       return x;

   }

}

Drawing.java

package ru.hse.android.diplom;

import android.app.Activity;

import android.content.Context;

import android.content.Intent;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Path;

import android.os.Bundle;

import android.graphics.Paint;

import android.view.View;

public class Drawing extends Activity {

   double[] nodes;

   int[] elements;

   float[] nodesfloat;

   double[] nodesNew;

   float[] nodesfloatNew;

   @Override

   protected void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);

       setContentView(new DrawView(this));

       Intent intent = getIntent();

       nodes = intent.getDoubleArrayExtra("nodes");

       elements = intent.getIntArrayExtra("elementsStr");

       nodesNew = intent.getDoubleArrayExtra("nodesNew");

       nodesfloat = new float[nodes.length];

       for (int i = 0 ; i < nodes.length; i++)

       {

           nodesfloat[i] = (float) nodes[i];

       }

       nodesfloatNew = new float[nodes.length];

       for (int i = 0 ; i < nodes.length; i++)

       {

           nodesfloatNew[i] = (float) nodesNew[i];

       }

   }

   class DrawView extends View {

       Paint re;

       Path path;

       Path path2;

       Matrix matrix;

       public DrawView(Context context) {

       super(context);

       re = new Paint();

       re.setStrokeWidth(3);

       re.setStyle(Paint.Style.STROKE);

       path = new Path();

       path2 = new Path();

       matrix = new Matrix();

       }

       protected void onDraw(Canvas canvas) {

           canvas.drawARGB(80, 102, 204, 255);

                       for (int i =0;i<2*(nodesfloat.length/3+5);) {

                           int ni = elements[i];

                           float xi1 = nodesfloat[ni * 3 - 3];

                           float zi1 = nodesfloat[ni * 3 - 1];

                           path.moveTo(30*(xi1)+getWidth()/4,30*(zi1)+getHeight()/2);

                           i++;

                           int nj = elements[i];

                           float xj1 = nodesfloat[nj * 3 - 3];

                           float zj1 = nodesfloat[nj * 3 - 1];

                           path.lineTo(30*(xj1)+getWidth()/4, 30*(zj1)+getHeight()/2);

                           i++;

                           re.setColor(Color.BLACK);

                           canvas.drawPath(path, re);

                       }

           for (int i =0;i<2*(nodesfloat.length/3+5);) {

               int ni = elements[i];

               float xi1 = nodesfloatNew[ni * 3 - 3];

               float zi1 = nodesfloatNew[ni * 3 - 1];

               path2.moveTo(30*(xi1)+getWidth()/4,30*(zi1)+getHeight()/2);

               i++;

               int nj = elements[i];

               float xj1 = nodesfloatNew[nj * 3 - 3];

               float zj1 = nodesfloatNew[nj * 3 - 1];

               path2.lineTo(30*(xj1)+getWidth()/4, 30*(zj1)+getHeight()/2);

               i++;

               re.setColor(Color.BLUE);

               canvas.drawPath(path2, re);

           }

       }

   }

}

Elements.java

package ru.hse.android.diplom;

class Elements {

static double[] findSigma(int[][] elements,double[]nodes, double modY,double[]displacements){

   double nodesNew[] = Nodes.lastNodes(displacements, nodes);

       double[] sigma = new double[elements.length];

       for (int i = 0; i < elements.length; i++) {

           int ni = elements[i][0];

           int nj = elements[i][1];

           double xi1 = nodes[ni * 3 - 3];

           double yi1 = nodes[ni * 3 - 2];

           double zi1 = nodes[ni * 3 - 1];

           double xj1 = nodes[nj * 3 - 3];

           double yj1 = nodes[nj * 3 - 2];

           double zj1 = nodes[nj * 3 - 1];

           double xi2 = nodesNew[ni * 3 - 3];

           double yi2 = nodesNew[ni * 3 - 2];

           double zi2 = nodesNew[ni * 3 - 1];

           double xj2 = nodesNew[nj * 3 - 3];

           double yj2 = nodesNew[nj * 3 - 2];

           double zj2 = nodesNew[nj * 3 - 1];

           double L1 = Math.sqrt((xi1 - xj1) * (xi1 - xj1) + (yi1 - yj1) * (yi1 - yj1) + (zi1 - zj1) * (zi1 - zj1));

           double L2 = Math.sqrt((xi2 - xj2) * (xi2 - xj2) + (yi2 - yj2) * (yi2 - yj2) + (zi2 - zj2) * (zi2 - zj2));

           sigma[i] = modY * (L2 - L1) / L1;

       }

       return sigma;

   }

   static int[][] defineElements(int kUzl)

   {

       int arr[][] = new int[15*kUzl/4 - 9][2];

       for (int i = 1; i <= kUzl/4-1 ; i++) {arr[2*i - 2][0] = i;arr[2*i - 1][0] = i;arr[2*i - 2][1] = i+1;arr[2*i - 1][1] = i+2;}

       for (int i = kUzl/4; i <= kUzl/2-4 ; i=i+2) {arr[2*i-2][0] = i;arr[2*i-2][1] = i+1;arr[2*i][0] = i;arr[2*i][1] = i+3;arr[2*i-1][0] = i;arr[2*i-1][1] = i+2;}

       for (int i = kUzl/4 +1; i <= kUzl/2 -3 ; i = i+2) {arr[2*i-1 ][0] = i;arr[2*i-1 ][1] = i+2;}

       for (int i = kUzl/2 -2; i <= kUzl/2 -2 ; i = i+1) {arr[2*i - 2][0] = i;arr[2*i - 1][0] = i;arr[2*i - 2][1] = i+1;arr[2*i - 1][1] = i+2;}

       for (int i = kUzl/2 -1; i <= kUzl/2 -1 ; i = i+1) {arr[2*i-2 ][0] = i;arr[2*i-2][1] = i+1;}

       for (int i = kUzl/2 +1; i <= 3*kUzl/4-1 ; i++) {arr[2*i - 5][0] = i;arr[2*i - 4][0] = i;arr[2*i - 5][1] = i+1;arr[2*i - 4][1] = i+2;}

       for (int i = 3*kUzl/4; i <= kUzl-4 ; i=i+2) {arr[2*i-5][0] = i;arr[2*i-5][1] = i+1;arr[2*i-3][0] = i;arr[2*i-3][1] = i+3;arr[2*i-4][0] = i;arr[2*i-4][1] = i+2;}

       for (int i = 3*kUzl/4 +1; i <= kUzl -3 ; i = i+2) {arr[2*i-4 ][0] = i;arr[2*i-4 ][1] = i+2;}

       for (int i = kUzl -2; i <= kUzl -2 ; i = i+1) {arr[2*i - 4][0] = i;arr[2*i - 5][0] = i;arr[2*i - 4][1] = i+2;arr[2*i - 5][1] = i+1;}

       for (int i = kUzl -1; i <= kUzl -1 ; i = i+1){arr[2*i-5 ][0] = i;arr[2*i-5 ][1] = i+1;}

       for (int i = 1; i <= kUzl/2 ; i = i+1){arr[2*kUzl-7+i ][0] = i;arr[2*kUzl-7+i ][1] = i+kUzl/2;}

       for (int i = 1; i <= kUzl/2-2 ; i = i+1){ if (i == 1) {arr[5*kUzl/2+i-7][0]=i;arr[5*kUzl/2+i-7][1]=i+1+kUzl/2;}else {arr[5*kUzl/2+i-7][0]=i;arr[5*kUzl/2+i-7][1]=i+2+kUzl/2;}}

       arr[3*kUzl-8][0] = 2;arr[3*kUzl-8][1] = 1+kUzl/2;

       for (int i = 4; i<= kUzl/2; i++){arr[3*kUzl+i-11][0]=i;arr[3*kUzl+i-11][1]=i-2+kUzl/2;}

       arr[7*kUzl/2-10][0] = 1;arr[7*kUzl/2-10][1] = kUzl/2+3;arr[7*kUzl/2-9][0] = kUzl/2;arr[7*kUzl/2-9][1] = kUzl-1;

       int j=1;

       for(int i=3;i<=kUzl/2-1;i=i+2){arr[7*kUzl/2-9+j][0] = i;arr[7*kUzl/2-9+j][1] = kUzl/2-1+i;j=j+1; }

       return arr;

   }

}

Forces.java

package ru.hse.android.diplom;

class Forces {

   static final double g = 9.81;

   static double[]applyP (double[]forces, double kUzl,double P) {

       double[] applyP =new double[forces.length];

       for (int i = 0; i < 3 * kUzl; i++) {

           if (i % 6 == 5) {

               applyP[i] = forces[i] - P * g;

           }

       }

       return applyP;

   }

   static double[] findEpsAndVar (double Krit,double P, double eps,int taskType,int[][] elements,double []nodes, double modY,double[] displacements) {

       double[] sigma =Elements.findSigma (elements,nodes,modY,displacements);

       double max = MathOperations.maxInString(sigma);

       double[] epsAndP =new double[2];

       if (taskType==1) {

           if (max > Krit) {

               P = P - P * eps;

               eps = eps / 1.2;

           } else {

               P = P + P * eps;

               eps = eps / 1.2;

           }

       }

       else

       if (max < Krit) {

           P = P - P * eps;

           eps = eps / 1.02;

       } else {

           P = P + P * eps;

           eps = eps / 1.02;

       }

       epsAndP[0]=eps;

       epsAndP[1]=P;

       return epsAndP;

   }

   static double[] defineGravity(int nodesNumb,double H,double L, double W, double A, int ro, double g)

   {

       double HL = Math.sqrt(H*H + L*L);

       double WL = Math.sqrt(W*W + L*L);

       double HWL = Math.sqrt(H*H + WL*WL);

       double  WH = Math.sqrt(H*H + W*W);

       double V1 = H * A;

       double V2 = L * A;

       double V3 = HL * A;

       double V4 = W * A;

       double V5 = WL*A;

       double V6 = HWL*A;

       double V7 = WH*A;

       double m1 = V1 * ro;

       double m2 = V2 * ro;

       double m3 = V3 * ro;

       double m4 = V4*ro;

       double m5 = V5*ro;

       double m6 = V6*ro;

       double m7 = V7*ro;

       double F1  = m1 * g / 2;

       double F2 =  m2 * g / 2;

       double F3 =  m3 * g / 2;

       double F4 =  m4* g / 2;

       double F5 =  m5* g / 2;

       double F6 =  m6* g / 2;

       double F7 =  m7* g / 2;

       double forc[][] = new double[nodesNumb][3];

       forc[0][2] =  -(F2+F3+F4+F5+F6);

       forc[1][2] =  -(2*F2+F1+F4+2*F5);

       forc[2][2] =  -(F1+F2+2*F3+F4+F5+F7);

       if (nodesNumb != 16)

       {

           for (int i = 4;i <= nodesNumb/4-2;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5);

           }

       }

       if (nodesNumb != 16)

       {

           for (int i = 5;i <= nodesNumb/4-1;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5+F7);

           }

       }

       forc[nodesNumb/4-1][2] = -(F1+2*F2+2*F3+F4+2*F5);

       forc[nodesNumb/4][2] = -(F1+2*F2+F4+2*F5+F7);

       if (nodesNumb != 16)

       {

           for (int i = nodesNumb/4+2;i <= nodesNumb/2-4;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5);

           }

       }

       if (nodesNumb != 16)

       {

           for (int i = nodesNumb/4+3;i <= nodesNumb/2-3;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5+F7);

           }

       }

       forc[nodesNumb/2-3][2] = -(F1+2*F2+F4+2*F5);

       forc[nodesNumb/2-2][2]= -(F1+F2+2*F3+F4+F5+F7);

       forc[nodesNumb/2-1][2]= -(F2+F3+F4+F5+F6);

       forc[nodesNumb/2][2]= -(F2+F3+F4+F5);

       forc[nodesNumb/2+1][2]= -(F1+2*F2+F4+2*F5+F7);

       forc[nodesNumb/2+2][2]= -(F1+F2+2*F3+F4+F5+F6);

       if (nodesNumb != 16)

       {

           for (int i = nodesNumb/2+4;i <= 3*nodesNumb/4-2;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5+F7);

           }

       }

       if (nodesNumb != 16)

       {

           for (int i = nodesNumb/2+5;i <= 3*nodesNumb/4-1;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5);

           }

       }

       forc[3*nodesNumb/4-1][2]= -(F1+2*F2+2*F3+F4+2*F5+F7);

       forc[3*nodesNumb/4][2] = -(F1+2*F2+F4+2*F5);

       if (nodesNumb != 16)

       {

           for (int i = 3*nodesNumb/4+2;i <= nodesNumb-4;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5+F7);

           }

       }

       if (nodesNumb != 16)

       {

           for (int i = 3*nodesNumb/4+3;i <= nodesNumb-3;i=i+2)

           {

               forc[i-1][2] = -(F1+2*F2+F3+F4+2*F5);

           }

       }

       forc[nodesNumb-3][2]=-(F1+2*F2+F4+2*F5+F7);

       forc[nodesNumb-2][2]=-(F1+F2+2*F3+F4+F5+F6);

       forc[nodesNumb-1][2]=-(F2+F3+F4+F5);

       double[] forces = MathOperations.reshape(forc, 3, nodesNumb);

       return forces;

   }

   static int[] BoundaryCondition(int nodesNumb,double[] forces) {

   int[][] ux = {{1, 0}, {nodesNumb / 2, 1}, {nodesNumb / 2 + 1, 0}, {nodesNumb, 1}};

   int[][] uy = {{1, 0}, {nodesNumb / 2, 0}, {nodesNumb / 2 + 1, 0}, {nodesNumb, 0}};

   int[][] uz = {{1, 0}, {nodesNumb / 2, 0}, {nodesNumb / 2 + 1, 0}, {nodesNumb, 0}};

   int m[] = new int[10];

   int p = 0;

   for (int i = 0; i < 4; i++) {

       if (ux[i][1] != 1) {

           forces[3 * ux[i][0] - 3] = ux[i][1];

           m[p] = 3 * ux[i][0] - 3;

           p++;

       }

       forces[3 * uy[i][0] - 2] = uy[i][1];

       m[p] = 3 * uy[i][0] - 2;

       p++;

       forces[3 * uz[i][0] - 1] = uz[i][1];

       m[p] = 3 * uz[i][0] - 1;

       p++;

   }

       return m;

   }

}

Input.java

package ru.hse.android.diplom;

import android.content.Intent;

import android.support.v7.app.ActionBarActivity;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

import android.widget.EditText;

import android.widget.TextView;

public class Input extends ActionBarActivity implements View.OnClickListener{

   EditText editText;

   EditText editText2;

   EditText editText3;

   EditText editText4;

   EditText editText5;

   EditText editText6;

   Button button2;

   public int num;

   String idAlbum;

   TextView textView8;

   TextView textView9;

   TextView textView10;

   TextView textView11;

   TextView textView12;

   TextView textView13;

   @Override

   protected void onCreate(Bundle savedInstanceState)  {

       super.onCreate(savedInstanceState);

       setContentView(R.layout.input);

       editText = (EditText) findViewById(R.id.editText);

       editText2 = (EditText) findViewById(R.id.editText2);

       editText3 = (EditText) findViewById(R.id.editText3);

       editText4 = (EditText) findViewById(R.id.editText4);

      editText5 = (EditText) findViewById(R.id.editText5);

       editText6 = (EditText) findViewById(R.id.editText6);

       button2 = (Button) findViewById(R.id.button2) ;

       button2.setOnClickListener(this);

       textView8 = (TextView) findViewById(R.id.textView8);

       textView9 = (TextView) findViewById(R.id.textView9);

       textView10 = (TextView) findViewById(R.id.textView10);

       textView11 = (TextView) findViewById(R.id.textView11);

       textView12 = (TextView) findViewById(R.id.textView12);

       textView13 = (TextView) findViewById(R.id.textView13);

       button2.setOnClickListener(this);

       Bundle extras = getIntent().getExtras();

       if (extras != null) {

          idAlbum = String.valueOf(extras.getLong("id"));

           num = Integer.parseInt(idAlbum);

           textView8.setText(R.string.input_w);

           textView9.setText(R.string.input_h);

           textView10.setText(R.string.input_numSec);

           textView11.setText(R.string.input_scale);

           editText.setText("1", TextView.BufferType.EDITABLE);

           editText2.setText("2", TextView.BufferType.EDITABLE);

           editText3.setText("14", TextView.BufferType.EDITABLE);

           editText4.setText("1", TextView.BufferType.EDITABLE);

           switch (num) {

               case 1:

                   editText5.setText("3", TextView.BufferType.EDITABLE);

                   editText6.setText("0.01", TextView.BufferType.EDITABLE);

                   textView12.setText(R.string.input_l);

                   textView13.setText(R.string.input_s);

                   break;

               case 2:

                   editText5.setText("3", TextView.BufferType.EDITABLE);

                   editText6.setText("25000", TextView.BufferType.EDITABLE);

                   textView12.setText(R.string.input_l);

                   textView13.setText(R.string.input_p);

                   break;

               case 3:

                   editText5.setText("0.01", TextView.BufferType.EDITABLE);

                   editText6.setText("25000", TextView.BufferType.EDITABLE);

                   textView12.setText(R.string.input_s);

                   textView13.setText(R.string.input_p);

                   break;

           }

      }

   }

   @Override

   public void onClick(View v) {

       Intent intent = new Intent(this, Result.class);

       final String str1 = editText.getText().toString();

       final String str2 = editText2.getText().toString();

       final String str3 = editText3.getText().toString();

       final String str4 =  editText4.getText().toString();

       final String str5 =  editText5.getText().toString();

       final String str6 =  editText6.getText().toString();

       intent.putExtra("width", str1);

       intent.putExtra("hight", str2);

       intent.putExtra("sections", str3);

       intent.putExtra("scale", str4);

       intent.putExtra("num", idAlbum);

       switch (num) {

           case 1:

          intent.putExtra("length", str5);

           intent.putExtra("area", str6);

           break;

           case 2:

           intent.putExtra("length", str5);

           intent.putExtra("payload", str6);

              break;

           case 3:

           intent.putExtra("area", str5);

           intent.putExtra("payload", str6);

         break;

       }

       startActivity(intent);

   }

}

Main.java

package ru.hse.android.diplom;

import java.util.Arrays;

public class Main {

   public static double[] main(String num, String w,String sca, String h,String sec,String var1,String var2,int index ) {

int sc = Integer.parseInt(num);

       double width = Double.parseDouble(w);

       double hight = Double.parseDouble(h);

       int scale = Integer.parseInt(sec);

       int sectNum = Integer.parseInt(sca);

       double VAR1 = Double.parseDouble(var1);

       double VAR2 = Double.parseDouble(var2);

       double modY = 2.10E+11,sigmaT = 6E+8;

       int safetyFactor = 2,ro = 7800;

       double Krit = sigmaT / safetyFactor;

       int nodesNumb = 2 * sectNum + 4;

       int[][] elements;

       double[] forces,nodes,displacements;

       double[]nodesNew=new double[3*nodesNumb];

       double[] result =new double[1];

       result[0] = 0;

       double eps=0.5;

       int taskType;

       double length = 3;

       double payload = 25000;

       double crossSectionArea = 0.01;

       System.out.println("Введите тип задания:");

           switch (sc) {

               case 1:

                   taskType = 1;

                   length = VAR1; crossSectionArea = VAR2;

                   nodes = Nodes.defineNodes(nodesNumb, hight, length, width);

                   elements = Elements.defineElements(nodesNumb);

                   forces = Forces.defineGravity(nodesNumb, hight, length, width, crossSectionArea, ro, Forces.g);

                   payload = 2000000;

                   do

                   {

                       displacements = Displacements.findDisp(nodesNumb,elements,nodes,crossSectionArea, modY,forces,payload);

                       double[] epsP = Forces.findEpsAndVar(Krit,payload,eps,taskType,elements,nodes,modY,displacements);

                       eps=epsP[0];

                       payload = epsP[1];

                   }while(eps>0.0001);

                   nodesNew = Nodes.lastNodes(displacements, nodes);

                   System.out.println(Arrays.toString(displacements));

                   System.out.println(Arrays.toString(nodesNew));

                   System.out.println(payload);

                   result[0] = payload;

                   break;

              case 2:

                   taskType = 2;

                  length = VAR1;payload = VAR2;

                   nodes = Nodes.defineNodes(nodesNumb, hight, length, width);

                   elements = Elements.defineElements(nodesNumb);

                   crossSectionArea = 4000;

                   do

                   {

                       forces = Forces.defineGravity(nodesNumb, hight, length, width, crossSectionArea, ro, Forces.g);

                       displacements = Displacements.findDisp(nodesNumb,elements,nodes,crossSectionArea, modY,forces,payload);

                       double[] epsP = Forces.findEpsAndVar(Krit,crossSectionArea,eps,taskType,elements,nodes,modY,displacements);

                       eps=epsP[0];

                       crossSectionArea = epsP[1];

                   }while(eps>0.0001);

                   nodesNew = Nodes.lastNodes(displacements, nodes);

                  result[0] = crossSectionArea;

                   break;

               case 3:

                   taskType = 1;

                 payload = VAR2;crossSectionArea = VAR1;

                   length = 76;

                   do

                   {

                       nodes = Nodes.defineNodes(nodesNumb, hight, length, width);

                       elements = Elements.defineElements(nodesNumb);

                       forces = Forces.defineGravity(nodesNumb, hight, length, width, crossSectionArea, ro, Forces.g);

                       displacements = Displacements.findDisp(nodesNumb,elements,nodes,crossSectionArea, modY,forces,payload);

                       double[] epsP = Forces.findEpsAndVar(Krit,length,eps,taskType,elements,nodes,modY,displacements);

                       eps=epsP[0];

                       length = epsP[1];

                   }while(eps>0.0001);

                   nodesNew = Nodes.lastNodes(displacements, nodes);

                   System.out.println(Arrays.toString(displacements));

                   System.out.println(Arrays.toString(nodesNew));

                   System.out.println(length);

                   result[0] = length;

                   break;

default:

System.out.println("Вы не ввели один из указанных номеров");

break;

           }

       if (index == 1)

       {

           return result;

       }

       else

       {

           return nodesNew;

       }

   }

}

MathOperations.java

package ru.hse.android.diplom;

class MathOperations {

   static double maxInString(double[] mas)

   {

       double max = mas[0];

       int x = 0;

       for (int i = 0; i < mas.length; i++) {

           if (Math.abs(mas[i]) > max) {

               {

                   max = Math.abs(mas[i]);

                   x = i;

               }

           }

       }

       return max;

   }

   static double[] reshape(double[][] array, int str,int col)

   {

       int counter =0;

       double[] newArray = new double[col*str];

       for (int x =0;x < array.length;x++)

       {

           for (int y=0;y<array[x].length;y++)

           {

               newArray[counter] = array[x][y];

               counter++;

           }

       }

       return newArray;

   }

   static int[] reshapeInt(int[][] array, int str,int col)

   {

       int counter =0;

       int[] newArray = new int[col*str];

       for (int x =0;x < array.length;x++)

       {

           for (int y=0;y<array[x].length;y++)

           {

               newArray[counter] = array[x][y];

               counter++;

           }

       }

       return newArray;

   }

}

Nodes.java

package ru.hse.android.diplom;

class Nodes {

  static double[] defineNodes(int nodesNumb,double H,double L, double W)

   {

       double nodesArr[][] = new double[nodesNumb][3];

       for (int i = 1; i <= nodesNumb/2 ; i=i+2) {nodesArr[i][0] = L*(i+1)/2;nodesArr[i][1] = 0; nodesArr[i][2] = 0;}

       for (int i = 2; i < nodesNumb/2  ; i=i+2) {nodesArr[i][0] = L*i/2;nodesArr[i][1] = 0; nodesArr[i][2] = H;}

       nodesArr[nodesNumb/2][1] = 1;

       for (int i = nodesNumb/2 + 1; i <= nodesNumb  ; i=i+2) {nodesArr[i][0] = nodesArr[i-nodesNumb/2][0];nodesArr[i][1] = W; nodesArr[i][2] = 0;}

       for (int i = nodesNumb/2 + 2; i < nodesNumb   ; i=i+2) {nodesArr[i][0] = nodesArr[i-nodesNumb/2][0];nodesArr[i][1] = W; nodesArr[i][2] = H;}

       double[] nodes = MathOperations.reshape(nodesArr, 3, nodesNumb);

       return nodes;

   }

   static double[] lastNodes(double[] movements,double[]Nodes)

   {

       double[] nodesNew =new double[movements.length];

       for (int i=0;i<movements.length;i++)

       {

           nodesNew[i] = movements[i] + Nodes[i];

       }

       return nodesNew;

   }

}

Result.java

package ru.hse.android.diplom;

import android.content.Intent;

import android.support.v7.app.ActionBarActivity;

import android.os.Bundle;

import android.widget.TextView;

import android.widget.Toast;

import java.lang.*;

import java.util.Arrays;

public class Result extends ActionBarActivity {

   public int var;

   @Override

   protected void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);

       setContentView(R.layout.result);

       String length;

       String area;

       String payload;

       String num;

       String width;

       String hight;

       String sections;

       String scale;

       double[] result = new double[1];

       Intent intent = getIntent();

       width= intent.getStringExtra("width");

       hight=intent.getStringExtra("hight");

       sections=intent.getStringExtra("sections");

       scale=intent.getStringExtra("scale");

       num = intent.getStringExtra("num");

       var = Integer.parseInt(num);

       int nodesNumb = 2 * Integer.parseInt(sections) + 4;

       double h = Integer.parseInt(hight);

       double w = Integer.parseInt(width) ;

       int j = 1;

       int i = 2;

           switch (var) {

               case 1:

                    length=intent.getStringExtra("length");

                    area=intent.getStringExtra("area");

                    double l = Integer.parseInt(length) ;

                   result = Main.main(num,width,sections,hight,scale,length,area,j);

                   double otvet =  result[0];

                   Toast toast = Toast.makeText(getApplicationContext(),"Полезная нагрузкa" + Double.toString(otvet)

                   ,Toast.LENGTH_LONG );

                   toast.show();

                   TextView myText4 = (TextView)findViewById(R.id.textView2);

                   myText4.setText("Результат " + otvet);

                   double[] nodes=Nodes.defineNodes(nodesNumb,h,l,w);

                   double[] nodesNew = Main.main(num,width,sections,hight,scale,length,area,i);

                   System.out.println(Arrays.toString(nodesNew));

                   int[][]elements = Elements.defineElements(nodesNumb);

                   Intent drw = new Intent (this, Drawing.class);

                   int[] elementsStr = MathOperations.reshapeInt(elements,elements.length,2);

                   drw.putExtra("nodes", nodes);

                   drw.putExtra("elementsStr", elementsStr);

                   drw.putExtra("nodesNew", nodesNew);

                   break;

               case 2:

                   length=intent.getStringExtra("length");

                   payload=intent.getStringExtra("payload");

                   l = Integer.parseInt(length) ;

                  result = Main.main(num,width,sections,hight,scale,length,payload,j);

                   otvet =  result[0];

                   toast = Toast.makeText(getApplicationContext(),"Площадь сечения" +Double.toString(otvet)

                           , Toast.LENGTH_LONG );

                   toast.show();

                   TextView myText2 = (TextView)findViewById(R.id.textView2);

                   myText2.setText("Результат " + otvet);

                    nodes =Nodes.defineNodes(nodesNumb, h, l, w);

                   nodesNew = Main.main(num,width,sections,hight,scale,length,payload,i);

                   System.out.println(Arrays.toString(nodesNew));

                   System.out.println(Arrays.toString(nodes));

                   System.out.println("222");

                   elements =  Elements.defineElements(nodesNumb);

                  drw = new Intent (this, Drawing.class);

                   elementsStr = MathOperations.reshapeInt(elements,elements.length,2);

                   drw.putExtra("nodes", nodes);

                   drw.putExtra("elementsStr", elementsStr);

                   drw.putExtra("nodesNew", nodesNew);

                   startActivity(drw);

                   break;

               case 3:

                   area=intent.getStringExtra("area");

                   payload=intent.getStringExtra("payload");

                   result = Main.main(num,width,sections,hight,scale,area,payload,j);

                   otvet =  result[0];

                   toast = Toast.makeText(getApplicationContext(),"Длина секции" +Double.toString(otvet)

                            , Toast.LENGTH_LONG );

                   toast.show();

                   TextView myText3 = (TextView)findViewById(R.id.textView2);

                   myText3.setText("Результат " + otvet);

                   nodes = Nodes.defineNodes(nodesNumb,h,otvet,w);

                  nodesNew = Main.main(num,width,sections,hight,scale,area,payload,i);

                   elements = Elements.defineElements(nodesNumb);

                   elementsStr = MathOperations.reshapeInt(elements,elements.length,2);

                   drw = new Intent (this, Drawing.class);

                   drw.putExtra("nodes", nodes);

                   drw.putExtra("elementsStr", elementsStr);

                   drw.putExtra("nodesNew", nodesNew);

                   startActivity(drw);

                   break;

           }

       }

}

StiffnessMatrix.java

package ru.hse.android.diplom;

public class StiffnessMatrix {

    static double[][] findStiffnessMatrix(int[][] elements, double[] nodes, double crossSectionArea,double modY,int nodesNumb)

   {

       double[][] K = new double[3*nodesNumb][3*nodesNumb];

       for (int i = 0; i < elements.length; i++) {

           int ni = elements[i][0];

           int nj = elements[i][1];

           int[] EFT = {ni * 3 - 3, ni * 3 - 2, ni * 3 - 1, nj * 3 - 3, nj * 3 - 2, nj * 3 - 1};

           double xi = nodes[ni * 3 - 3];

           double yi = nodes[ni * 3 - 2];

           double zi = nodes[ni * 3 - 1];

           double xj = nodes[nj * 3 - 3];

           double yj = nodes[nj * 3 - 2];

           double zj = nodes[nj * 3 - 1];

           double dx = xj - xi;

           double dy = yj - yi;

           double dz = zj - zi;

           double l = Math.sqrt(dx * dx + dy * dy + dz * dz);

           double cx = dx / l;

           double cy = dy / l;

           double cz = dz / l;

           double[][] matrix = {

                   {cx * cx, cx * cy, cx * cz, -cx * cx, -cx * cy, -cx * cz},

                   {cx * cy, cy * cy, cy * cz, -cx * cy, -cy * cy, -cy * cz},

                   {cx * cz, cy * cz, cz * cz, -cx * cz, -cy * cz, -cz * cz},

                   {-cx * cx, -cx * cy, -cx * cz, cx * cx, cx * cy, cx * cz},

                   {-cx * cy, -cy * cy, -cy * cz, cx * cy, cy * cy, cy * cz},

                   {-cx * cz, -cy * cz, -cz * cz, cx * cz, cy * cz, cz * cz},

           };

           for (int sch = 0; sch < matrix.length; sch++) {

               for (int j = 0; j < matrix.length; j++) {

                   matrix[sch][j] *= (modY * crossSectionArea / l);

               }

           }

           int index1 = 0;

           int index2 = 0;

           int x, y;

           do {

               x = EFT[index1];

               do {

                   y = EFT[index2];

                   K[x][y] = K[x][y] + matrix[index1][index2];

                   index2++;

               } while (index2 <= 5);

               index2 = 0;

               index1++;

           } while (index1 <= 5);

       }

       return K;

   }

   static double[][]modifyK(int nodesNumb, int[][] elements,double[] nodes, double crossSectionArea, double modY,double[] applyGravity) {

       int[] m = Forces.BoundaryCondition(nodesNumb,applyGravity);

       double[][] K= StiffnessMatrix.findStiffnessMatrix(elements, nodes,crossSectionArea,modY,nodesNumb);

       for (int j = 0; j < 3 * nodesNumb; j++) {

           for (int k = 0; k < m.length; k++) {

               if (j == m[k]) {

                   for (int i = 0; i < 3 * nodesNumb; i++) {

                       if (i == j) {

                           K[i][j] = 1;

                       } else {

                           K[j][i] = 0;

                           K[i][j] = 0;

                       }

                   }

               }

           }

       }

       return K;

   }

}

Task.java

import android.app.AlertDialog;

import android.app.Dialog;

import android.app.DialogFragment;

import android.content.DialogInterface;

import android.content.DialogInterface.OnClickListener;

import android.os.Bundle;

import android.util.Log;

public class Task extends DialogFragment implements OnClickListener {

   final String LOG_TAG = "myLogs";

   public Dialog onCreateDialog(Bundle savedInstanceState) {

       AlertDialog.Builder adb = new AlertDialog.Builder(getActivity())

               .setTitle("Title!").setPositiveButton(R.string.OK, this)

               .setMessage(R.string.message_text);

       return adb.create();

   }

   public void onClick(DialogInterface dialog, int which) {

       int i = 0;

       switch (which) {

           case Dialog.BUTTON_POSITIVE:

               i = R.string.OK;

               break;

       }

       if (i > 0)

           Log.d(LOG_TAG, "Dialog 2: " + getResources().getString(i));

   }

}




Похожие работы, которые могут быть Вам интерестны.

1. ИССЛЕДОВАНИЕ ЭЛЕМЕНТОВ ЭЛЕКТРИЧЕСКИХ ЦЕПЕЙ

2. ИССЛЕДОВАНИЕ МЕТОДА НЕФАРМАКОЛОГИЧЕСКОЙ СТИМУЛЯЦИИ МЕДЛЕННОВОЛНОВОГО СНА

3. Исследование проблемы оптимально управления в динамической односекторной экономической модели с дискретным временем и общими граничными условиями на основе метода динамического программирования

4. Практические методы расчета конечных деформаций оснований фундаментов. Осадка фундамента методом послойного суммирования

5. Типология метода проектов. Оценивание метода проектов. Проект Гражданин

6. Возникновение научного метода. Сущность и развитие научного метода

7. Анализ элементов и содержание проекта

8. ОБРАБОТКА НА ВАЛАХ ЭЛЕМЕНТОВ ТИПОВЫХ СОПРЯЖЕНИЙ

9. РАСЧЕТ И КОНСТРУИРОВАНИЕ ЭЛЕМЕНТОВ СБОРНОГО ПЕРЕКРЫТИЯ

10. КОНСТРУИРОВАНИЕ ЭЛЕМЕНТОВ ИНФОРМАЦИОННО-ИЗМЕРИТЕЛЬНОЙ ТЕХНИКИ