Уравнение с модулем линейное: Ошибка 403 — доступ запрещён

виды уравнение, методы решения, пояснение на примерах

Что такое уравнение с модулем 

Модуль числа — абсолютная величина, демонстрирующая удаленность точки от начала координат.

В том случае, когда число является отрицательным, его модуль соответствует числу, ему противоположному. Для неотрицательного числа модуль равен этому числу.

Модуль числа:

|x|=x, x≥0 -x, x<0

Уравнения с модулем являются такими уравнениями, в составе которых имеется переменная, заключенная в знак модуля.

Самое простое уравнение с модулем |f(x)|=a является равносильным совокупности

f(x)=a

f(x)=-a

Здесь a>0. При а отрицательном у такого уравнения отсутствует решение.

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

Разберем подробное решение квадратного уравнения:

x2=16

Заметим, что справа имеется квадрат числа 4:

x2=42

На первый взгляд, нужно избавиться от квадратов, чтобы получить линейное уравнение. С другой стороны, существует правило:

x2=x

Вычисления следует продолжить с учетом записанной формулы. Тогда получим уравнение с модулем:

x2=42 ⇔ x2=42 ⇔ x=4

Рассмотрим для тренировки пример, когда уравнения с модулем появляются при решении иррациональных уравнений. Например, дано уравнение:

2x-12=9×2+12x+4

Согласно стандартному алгоритму действий, в этом случае потребуется выполнить действия:

• перенос слагаемых;
• приведение подобных;
• решение квадратного уравнения, например, с помощью дискриминанта.

Второй вариант решения предусматривает использование формулы сокращенного умножения квадрат суммы:

9×2+12x+4=3x+22

Преобразуем сложное уравнение:

2x-12=3x+22

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

x2=x

В результате получим:

2x-12=3x+22 ⇔ 2x-1=3x+2.

При решении уравнений, которые содержат модуль, необходимо помнить свойства модуля:

1. Модуль числа является неотрицательным числом: x≥0,x=0⇔x=0.
2. Противоположные числа равны друг другу по модулю: -x=x.
3. Произведение пары или более чисел по модулю равно произведению модулей этих чисел: x·y=x·y.
4. Частное пары чисел по модулю равно частному модулей этих чисел: xy=xy,y≠0.
5. Сумма чисел по модулю в любом случае меньше или равна сумме модулей данных чисел:x+y≤x+y.
6. Постоянный множитель, который больше нуля, допустимо вынести за знак модуля: cx=c·x при c>0.
7. Квадрат какого-то числа по модулю равен квадрату данного числа: x2=x2.

Руководствуясь перечисленными свойствами модуля, рассмотрим решение уравнения:

x=7

Заметим, чтоxравен x при x больше либо равно нулю. Значение –x возможно, когда x является отрицательным числом. Таким образом:

x=7⇔x=7, при x≥0-x=7, при x<0⇔x=7x=-7

Рассмотрим несколько иное уравнение:

x=-7

В этом случае логика такая же, как в предыдущем примере:

x=-7⇔x=-7,  при x≥0-x=-7,  при x<0⇔x=-7x≥0⇒ решения нетx=7x<0 ⇒ решения нет

Способы решения уравнений с модулями для 10 и 11 классов

Существует три основных вида уравнений с модулем, которые предусматривают определенные подходы к решению:

1. Уравнения x=a.x=a⇔x=a, при x≥0-x=a, при x<0⇔x=ax=-a.
3. Уравнения вида x=y.x=y ⇔ y≥0x=yx=-y

Примеры решения задач с объяснением

Уравнения, которые содержат модуль и имеют вид |x| = |a|, решают с помощью определения модуля.

Рассмотрим в качестве примера:

x=5

Определим x. Когда x≥0, значение равно х. Если x<0, то значение соответствует –х. Таким образом:

x=5⇔x=5 при x≥0-x=5 при x<0⇔x=5x=-5.

Получим, что решением уравнения являются -5; 5.

Рассмотрим следующее задание, в рамках которого необходимо решить уравнение:

x=-3

Воспользуемся стандартным алгоритмом:

x=-3⇔x=-3 при x≥0-x=-3 при x<0⇔x=-3x≥0⇒ решений нетx=3x<0⇒ решений нет

Согласно первому свойству модуля:

x≥0, то есть модуль в любом случае не является отрицательным числом.

Можно обобщить рассмотренные действия и записать правило для решения уравнений, которые имеют вид x=a. Данное правило можно использовать в работе:

x=a ⇒ a≥0x=ax=-a.

Используя данное правило, решим уравнение:

x-5=3

По сравнению с предыдущим примером, здесь под знаком модуля записано иное выражение. Однако суть решения от этого не меняется. Зная правило, выполним замену:

x на x-5

a=3

Таким образом:

x-5=3⇔3≥0x-5=3x-5=-3⇒x=8x=2

Решим следующее уравнение:

3x-5=3

Воспользуемся правилом и получим:

3x-5=3⇔3≥03x-5=33x-5=-3⇒x=83x=23

Далее рассмотрим решение уравнений, которые записаны в виде |x| = |y|.

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

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

x2=x2.

Применим это свойство к нашему примеру и исключим знаки модулей из уравнения:

x=y ⇔x2=y2⇔x2=y2⇔x2-y2=0⇔

Таким образом:

⇔x-yx+y=0⇔x=yx=-y.

Рассмотрим еще несколько примеров.

Решим уравнение:

x+1=2x-1

Воспользуемся рассмотренным правилом применения свойства модуля, получим:

x+1=2x-1 ⇔ x+1=2x-1x+1=-2x-1 ⇔ x=2x=0.

Другой пример:

2x-9=3-x

Решение выполняем по аналогии с предыдущими заданиями:

2x-9=3-x⇔2x-9=3-x2x-9=x-3⇔3x=12x=6⇔x=4x=6.

Разберем на примере, как решать уравнения вида |x| = y.

Заметим, что справа записана переменная, которая может быть положительным или отрицательным числом. Исходя из того, что модуль не может быть отрицательным числом, убедимся в том, что эта переменная также не является отрицательным числом:

x=y ⇔ y≥0x=yx=-y

Решим уравнение:

x+1=1-2x

Воспользуемся стандартным алгоритмом:

x+1=1-2x ⇔ 1-2x≥0x+1=1-2xx+1=2x-1 ⇔ x≤12x=0x=2 ⇔ x=0.

Заметим, что без проверки на положительность части уравнения, которая записана с правой стороны, существуют риски появления посторонних корней в решении. К примеру, проверим x=2 путем подстановки в начальное уравнение x+1=1-2x:

2+1=1-2·2 ⇔ 3=-3  не является верным.

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

Рассмотрим пример такого выражения:

x+3-2x-1=1

Первый модуль имеет вид:

x+3

Согласно определению модуля, при раскрытии знака выражение под ним сохраняется без изменений, если:

x+3≥0

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

x+3<0

Таким образом:

x+3=x+3, если x+3≥0-x-3, если x+3<0.

По аналогии выполним преобразования второго модуля:

2x-1=2x-1, если 2x-1≥01-2x, если 2x-1<0.

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

Заметим, что в нашем примере не предусмотрено одновременное выполнение всех условий:

x+3<0

2x-1≥0

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

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

x+3=0 ⇒ x=-32x-1=0 ⇒ x=12

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

Первый интервал:

x<-3.

В этом случае оба модуля раскрываются со знаком минус:

-x+3+2x-1=1 ⇔ -x-3+2x-1=1 ⇔ x=5 >-3  является сторонним корнем.

Второй интервал:

-3≤x<12.

В данном выражении первый модуль раскроется со знаком плюс, а второй — со знаком минус:

x+3+2x-1=1 ⇔ x+3+2x-1=1 ⇔ x=-13  полученный корень соответствует своему интервалу.

Третий интервал:

x≥12.

Теперь для обоих модулей будет записан знак плюс:

x+3-2x-1=1 ⇔ x+3-2x+1=1 ⇔ x=3 данный корень также подходит для решения.

Выполним проверку корней. В первом случае корень посторонний:

x=5: 5+3-2·5-1=8-9=-1≠1

Второй корень является решением:

x=-13: -13+3-2·-13-1=83-53=1.

Третий корень также является решением:

x=3: 3+3-2·3-1=6-5=1.

Таким образом, запишем ответ:-13;3.

Существует ряд уравнений, в которых модуль расположен под знаком модуля. К примеру:

x-5=3

В этом случае следует раскрывать модули поочередно. Проанализируем два варианта решения.

Первое решение подразумевает вычисления для уравнения, которое имеет вид:

fx=a

Тогда:

fx=a ⇔ fx=afx=-a

Здесь fx является подмодульным выражением. Применительно к нашей задаче, это:

x-5

Таким образом:

x-5=3 ⇔ x-5=3x-5=-3 ⇔ x=8x=2

Получена пара простейших уравнений аналогичного вида, то есть:

x=8x=-8x=2x=-2

Данные четыре числа являются решениями. Проверить это можно путем подстановки ответов в исходное уравнение.

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

Раскроем сначала внутренние модули:

x-5=3

Начальное уравнение будет записано, как пара уравнений:

x-5=3

x≥0x-5=3x<0-x-5=3

Задачи для самостоятельного решения

Найти корни уравнения:

|2x-5|=x-1

Решение

Здесь нужно возвести в квадрат все части выражения, сохраняя знак плюса справа. Тогда получится система:

Найдем корни квадратного уравнения:

3×2-18x+24=0

В процессе потребуется сократить уравнение на 3:

x2-6x+8=0

Определим дискриминант:

D=(-6)2-4·1·8=36-32=4

Заметим, что D>0. В таком случае у уравнения есть пара решений, которые можно определить так:

x1,2=-b±D2a ⇒ x1,2=6±42·1 ⇒ x1,2=6±22 ⇒ x1=4 , x2=2

Заметим, что оба корня больше единицы. Это соответствует условию. В результате начальное уравнение обладает двумя решениями:

x1=4 и x2=2

Ответ: x1=4,x2=2

Найти корни уравнения:

|3x-1|=|x+5|

Решение

Здесь требуется возвести в квадрат обе части уравнения:

(3x-1)2=(x+5)2

9×2-6x+1=x2+10x+25

8×2-16x-24=0

Заметим, что получившееся равенство можно сократить на число 8:

x2-2x-3=0

Используя теорему Виета, определим корни уравнения. Предположим, что x1 и x2 являются в данном случае решениями, тогда:

x1+x2=2,аx1·x2=-3⇒x1=3 и x2=-1..

Ответ: x1=3,x2=-1

Нужно решить уравнение:

|x+1|+|x-5|=20

Решение

Воспользуемся методом интервалов. Определим х, при которых модули принимают нулевые значения:

x+1=0⇒x=-1;x-5=0⇒x=5

С помощью данных точек координатная прямая будет поделена на три интервала:

(-∞,-1]

(-1, 5]

(5,+∞)

Далее необходимо решить уравнение в каждом случае:

x∈(-∞,-1]

|x+1|=-x-1

|x-5|=-x+5

-x-1-x+5=20

-2x=16

x=-8

Корень соответствует определенному ранее промежутку.

x∈(-1,5]

|x+1|=x+1

|x-5|=-x+5

Этот промежуток не имеет корней.

x+1-x+5=20

0·x=14⇒x∈⊘

x∈(5,+∞)

|x+1|=x+1

|x-5|=x-5

x+1+x-5=20

2x=24

x=12

Этот корень соответствует определенному ранее интервалу.

Ответ: x1=-8,x2=12

Решить уравнение:

3x+1=1-2x

Решение

3x+1=1-2x ⇔3x+3=1-2x3x+3=2x-1⇔5x=-2x=-4⇔x=-25x=-4.

Ответ: x=-25,x=-4

Найти корни уравнения:

2x-9=3-x

Решение

2x-9=3-x  ⇔ 3-x≥02x-9=3-x2x-9=x-3 

x≤33x=12x=6⇔x≤3x=4x=6 ⇔x∈∅.

Ответ: x∈∅

Найти корни уравнения:

-2x+4=3-4x

Решение

-2x+4=3-4x⇔2x+8=4x-3⇔;

4x-3≥02x+8=4x-32x+8=3-4x⇔x≥34x=112x=-56⇔x=112.

Ответ: x=112

Найти корни уравнения:

2×2-15=x

Решение

2×2-15=x⇔x≥02×2-x-15=012×2+x-15=02

Найдем корни квадратных уравнений:

1и2

Заметим, что они обладают идентичным дискриминантом:

D=1+4·2·15=121=112.

Тогда:

1: x1,2=1±114 ⇔ x=3x=-52

2: x1,2=-1±114 ⇔ x=-3x=52

Таким образом, начальное уравнение можно записать в виде системы:

2×2-15=x ⇔ x≥0x=3x=-52x=-3x=52 ⇔ x=3x=52

Ответ: 2,5;3.

Найти корни уравнения:

x+2-3x-1+4-x=3

Решение

x+2-3x-1+4-x=3x+2=0  ⇒  x=-23x-1=0  ⇒ x=134-x=0  ⇒  x=4

-2≤x<13.

-x+2+3x-1+4-x=3

x=2>-2⇒ — этот корень является посторонним.

-2≤x<13

x+2+3x-1+4-x=3⇔

3x=-2⇔x=-23∈-2;13  этот корень удовлетворяет условиям.

13≤x<4

x+2-3x-1+4-x=3⇔-3x=-4⇔x=43∈13;4 этот корень удовлетворяет условиям.

x≥4

x+2-3x-1-4-x=3⇔x=4⇔x=-4<4— корень посторонний

Ответ: -23;43.

Найти корни уравнения:

3x-5+3+2x=2x+1

Решение

3x-5+3+2x=2x+1  ⇔  3x-5+3+2x-2x+1=0.

3x-5=0  ⇒ x=533+2x=0  ⇒ x=-32x+1=0    ⇒  x=-1

x<-32

-3x-5-3+2x+2x+1=0⇔

-3x=-4⇔x=43>-32⇒ — корень является посторонним

-32≤x<-1

-3x-5+3+2x+2x+1=0⇔

x=-10<-1⇒— корень является посторонним

-1≤x<53

-3x-5+3+2x-2x+1=0⇔

-3x=-6⇔x=2  >53⇒— корень является посторонним

x≥53

3x-5+3+2x-2x+1=0⇔

3x=4⇔x=43<53⇒ — корень является посторонним

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

Ответ: корни отсутствуют

Умбрако не может бежать. Подробнее см. в файле журнала Umbraco.-> Umbraco.Core.Exceptions.BootFailedException: Ошибка загрузки.-> System.TimeoutException: Не удалось получить MainDom в Umbraco.Core.Runtime.MainDom.Acquire() в D:\a\1\ s\src\Umbraco.Core\Runtime\MainDom.cs:строка 172 в System.Threading.LazyInitializer.EnsureInitializedCore[T](T& target, Boolean& initialized, Object& syncLock, Func`1 valueFactory) в Umbraco.Core.Runtime.MainDom .get_IsMainDom() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:строка 211 в Umbraco.Core.Runtime.CoreRuntime.AcquireMainDom(IMainDom mainDom) в D:\a\1\ s\src\Umbraco.Core\Runtime\CoreRuntime.cs:строка 460 в Umbraco.Core.Runtime.CoreRuntime.Boot(регистр IRegister, таймер DisposableTimer) в D:\a\1\s\s\src\Umbraco.Core\Runtime \CoreRuntime.cs:строка 185

-> Umbraco. Core.Exceptions.BootFailedException: Ошибка загрузки.

-> System.TimeoutException: невозможно получить MainDom
в Umbraco.Core.Runtime.MainDom.Acquire() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:строка 172
 в System.Threading.LazyInitializer.EnsureInitializedCore[T](T& target, Boolean& initialized, Object& syncLock, Func`1 valueFactory)
  в Umbraco.Core.Runtime.MainDom.get_IsMainDom() в D:\a\1\s\src\ Umbraco.Core\Runtime\MainDom.cs:строка 211
  в Umbraco.Core.Runtime.CoreRuntime.AcquireMainDom(IMainDom mainDom) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs:line 460
  в Umbraco.Core.Runtime.CoreRuntime.Boot (регистр IRegister, таймер DisposableTimer) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs:строка 185

-> System.TimeoutException: невозможно получить MainDom
  в Umbraco.Core.Runtime.MainDom.Acquire() в D:\a\1\s\src\Umbraco. Core\Runtime\MainDom.cs:строка 172
 в System.Threading.LazyInitializer.EnsureInitializedCore[T](T& target, Boolean& initialized, Object& syncLock, Func`1 valueFactory)
  в Umbraco.Core.Runtime.MainDom.get_IsMainDom() в D:\a\1\s\ src\Umbraco.Core\Runtime\MainDom.cs:line 211
  в Umbraco.Core.Runtime.CoreRuntime.AcquireMainDom(IMainDom mainDom) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs :line 460
  в Umbraco.Core.Runtime.CoreRuntime.Boot(регистр IRegister, таймер DisposableTimer) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs:строка 185 Описание: Произошло необработанное исключение во время выполнения текущего веб-запроса. Пожалуйста, просмотрите трассировку стека для получения дополнительной информации об ошибке и о том, где она возникла в коде.

Сведения об исключении: Umbraco.Core.Exceptions.BootFailedException: Ошибка загрузки: Umbraco не может работать. Дополнительные сведения см. в файле журнала Umbraco.

-> Umbraco.Core.Exceptions.BootFailedException: Ошибка загрузки.

-> System.TimeoutException: невозможно получить MainDom
  в Umbraco.Core.Runtime.MainDom.Acquire() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:строка 172
  в System.Threading.LazyInitializer.EnsureInitializedCore[T]( T& target, Boolean& initialized, Object& syncLock, Func`1 valueFactory)
  в Umbraco.Core.Runtime.MainDom.get_IsMainDom() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:line 211
  в Umbraco.Core.Runtime.CoreRuntime.AcquireMainDom(IMainDom mainDom) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs:line 460

Ошибка источника:

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

[BootFailedException: Ошибка загрузки: Umbraco не может работать. Дополнительные сведения см. в файле журнала Umbraco.
-> Umbraco.Core.Exceptions.BootFailedException: Ошибка загрузки.
->
  System.TimeoutException: невозможно получить MainDom
   в Umbraco.Core.Runtime.MainDom.Acquire() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:строка 172
   в System.Threading.LazyInitializer.EnsureInitializedCore[T](T& target, Boolean& Initialized, Object& syncLock, Func`1 valueFactory)
   в Umbraco.Core.Runtime.MainDom.get_IsMainDom() в D:\a\1\s\src\Umbraco.Core\Runtime\MainDom.cs:строка 211
   в Umbraco.Core.Runtime.CoreRuntime.AcquireMainDom(IMainDom mainDom) в D:\a\1\s\src\Umbraco.Core\Runtime\CoreRuntime.cs:строка 460
   в Umbraco.Core.Runtime.CoreRuntime.Boot (регистр IRegister, таймер DisposableTimer) в D:\a\1\s\src\Umbraco. Core\Runtime\CoreRuntime.cs:строка 185]
   Umbraco.Core.Exceptions.BootFailedException.Rethrow(BootFailedException bootFailedException) в D:\a\1\s\src\Umbraco.Core\Exceptions\BootFailedException.cs:64
   System.Web.SyncEventExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +223
   System.Web.HttpApplication.ExecuteStepImpl (шаг IExecutionStep) +220
   System.Web.HttpApplication.ExecuteStep (шаг IExecutionStep, логическое значение и выполнено синхронно) +94
 

Линейная эластичность

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

• Как решать линейные уравнения упругости с помощью дифференциальной и вариационные формы.

• Как решать задачи линейной упругости для трехмерных и тонких двумерных конструкций (плоскостное напряжение).

• Как обезразмерить уравнения упругости.

Примечание

В этом учебном пособии предполагается, что вы завершили учебное пособие по фоновой полости с приводом от крышки. и ознакомились с основами API модуля. См. Слабое решение PDE с использованием PINN. для более подробной информации о слабых решениях PDEs. Какая-то граница условия определены более подробно в учебнике Интерфейсная задача вариационным методом.

Уравнения линейной упругости в Modulus можно найти в каталог исходного кода modulus/PDES/linear_elasticity.

Уравнения линейной упругости в форме смещения

Форма смещения (непереходной) линейной упругости уравнений, известных как уравнения Навье, определяется как

, где \(u_i\) — вектор смещения, \(f_i\) — тело сила на единицу объема, а \(\lambda, \mu\) — параметры Ламе определяется как

Здесь \(E\), \(v\) — соответственно модуль Юнга и Коэффициент Пуассона.

Уравнения линейной упругости в смешанной форме

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

где \(\sigma_{ij}\) — тензор напряжений Коши. в уравнения напряжения-смещения также определяются как

, где \(\delta_{ij}\) — дельта-функция Кронекера, а \(\epsilon_{ij}\) — тензор деформации, который принимает следующую форму

Безразмерные линейные уравнения упругости

нормализованная вариация уравнений упругости для улучшения обучения сходимость и точность. Поэтому мы определяем безразмерные переменные как: 92/\mu_c U\), следующим образом:

, где безразмерная объемная сила и тензор напряжения равны

Аналогично, безразмерная форма напряжения-перемещения уравнения получаются умножением обеих частей уравнений на \(L/\mu_c U\), следующим образом:

Уравнения плоского напряжения

При плоском напряжении для тонких конструкций мы предполагаем, что

и, следовательно, выполняется следующее соотношение

Соответственно, уравнения для \( \ шляпа {\ сигма} _ {хх} \) и \(\hat{\sigma}_{yy}\) можно обновить следующим образом 94 \, \text{Pa}\) применяется к передней грани в отрицательное-\(z\) направление (эта грань показана красным). Остальная часть поверхность рассматривается как граница без сцепления. Набор \((E, \nu) = (100 \,\text{ГПа}, 0,3)\). Вы можете обезразмерить уравнения линейной упругости, устанавливая \(L=1 \,\text{m}, U=0,0001 \,\text{m}, \mu_c=0,01 \mu\).

Рис. 51 Геометрия кронштейна. Задняя грань кронштейна зажата, и к передней грани приложено напряжение сдвига в отрицательном направлении \(z\).

Копировать

Скопировано!

 
 # Указать параметры
    ню = 0,3
    Е = 100e9
    lambda_ = ню * E / ((1 + ню) * (1 - 2 * ню))
    мю = Е / (2 * (1 + ню))
    мю_с = 0,01 * мю
    лямбда_ = лямбда_ / мю_с
    мю = мю / мю_с
    характеристика_длина = 1,0
    характеристика_смещение = 1e-4
    сигма_нормализация = длина_характеристики / (смещение_характеристики * mu_c)
    T = -4e4 * сигма_нормализация 
         

Как правило, характеристическая длина может быть выбрана таким способ связать наибольшее измерение геометрии с \((-1,1)\). Характерное смещение и \(\mu_c\) также можно выбрать таким образом, чтобы максимальное смещение и приложенная тяга были близки к 1 по порядку. Хотя максимальное смещение заранее неизвестно, мы заметили, что сходимость не чувствительна к выбору характеристическое смещение, если оно разумно выбрано на основе по первоначальному предположению о приблизительном порядке перемещения.

Настройка случая и результаты

Полный скрипт Python для решения этой проблемы можно найти по адресу примеров/скобка/скобка.py . Две отдельные нейронные сети для перемещений и напряжений используются следующим образом:

Копия

Копия!

 
 # составить список узлов для развертывания графа
    le = LinearElasticity(lambda_=lambda_, mu=mu, dim=3)
    disp_net = instanceate_arch(
        input_keys=[Ключ("x"), Ключ("y"), Ключ("z")],
        output_keys=[Ключ("u"), Ключ("v"), Ключ("w")],
        cfg=cfg.arch.full_connected,
    )
    stress_net = instanceate_arch(
        input_keys=[Ключ("x"), Ключ("y"), Ключ("z")],
        выходные_ключи = [
            Ключ("sigma_xx"),
            Ключ("sigma_yy"),
            Ключ("sigma_zz"),
            Ключ("sigma_xy"),
            Ключ("sigma_xz"),
            Ключ("sigma_yz"),
        ],
        cfg=cfg.
  arch.full_connected,
    )
    узлы = (
        le.make_nodes()
        + [disp_net.make_node(name="displacement_network", jit=cfg.jit)]
        + [stress_net.make_node(name="stress_network", jit=cfg.jit)]
    ) 

         

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

Копировать

Скопировано!

 
 # добавить ограничения в решатель
    # сделать геометрию
    x, y, z = Символ ("x"), Символ ("y"), Символ ("z")
    support_origin = (-1, -1, -1)
    support_dim = (0,25, 2, 2)
    скобка_origin = (-0,75, -1, -0,1)
    скобка_dim = (1,75, 2, 0,2)
    цилиндр_радиус = 0,1
    высота_цилиндра = 2,0
    aux_lower_origin = (-0,75, -1, -0,1 - радиус_цилиндра)
    aux_lower_dim = (цилиндр_радиус, 2, цилиндр_радиус)
    aux_upper_origin = (-0,75, -1, 0,1)
    aux_upper_dim = (цилиндр_радиус, 2, цилиндр_радиус)
    цилиндр_нижний_центр = (-0,75 + цилиндр_радиус, 0, -0,1 - цилиндр_радиус)
    цилиндр_верхний_центр = (-0,75 + цилиндр_радиус, 0, 0,1 + цилиндр_радиус)
    цилиндр_отверстия_радиус = 0,7
    цилиндр_отверстие_высота = 0,5
    цилиндр_отверстие_центр = (0,125, 0, 0)
    поддержка = Коробка(
        support_origin,
        (
            support_origin[0] + support_dim[0],
            support_origin[1] + support_dim[1],
            support_origin[2] + support_dim[2],
        ),
    )
    скобка = коробка (
        скобка_происхождение,
        (
            скобка_происхождение[0] + скобка_dim[0],
            скобка_происхождение[1] + скобка_dim[1],
            скобка_происхождение[2] + скобка_dim[2],
        ),
    )
    aux_lower = Коробка(
        aux_lower_origin,
        (
            aux_lower_origin[0] + aux_lower_dim[0],
            aux_lower_origin[1] + aux_lower_dim[1],
            aux_lower_origin[2] + aux_lower_dim[2],
        ),
    )
    aux_upper = Коробка (
        aux_upper_origin,
        (
            aux_upper_origin[0] + aux_upper_dim[0],
            aux_upper_origin[1] + aux_upper_dim[1],
            aux_upper_origin[2] + aux_upper_dim[2],
        ),
    )
    цилиндр_нижний = цилиндр (цилиндр_нижний_центр, цилиндр_радиус, цилиндр_высота)
    цилиндр_верхний = цилиндр (цилиндр_верхний_центр, цилиндр_радиус, цилиндр_высота)
    цилиндр_отверстие = Цилиндр(
        цилиндр_отверстия_центр, цилиндр_отверстия_радиус, цилиндр_отверстия_высота
    )
    цилиндр_нижний. поворот (np.pi / 2, "х", цилиндр_нижний_центр)
    цилиндр_upper.rotate(np.pi/2, "х", цилиндр_верхний_центр)
    curve_lower = вспомогательный_нижний - цилиндр_нижний
    curve_upper = вспомогательный_верхний - цилиндр_верхний
    гео = опора + кронштейн + кривая_нижняя + кривая_верхняя - цилиндр_отверстие
    # Границы домена
    границы_х = (-1, 1)
    границы_у = (-1, 1)
    bounds_z = (-1, 1)
    bounds_support_x = (-1, -0,65)
    bounds_support_y = (-1, 1)
    bounds_support_z = (-1, 1)
    bounds_bracket_x = (-0,65, 1)
    bounds_bracket_y = (-1, 1)
    bounds_bracket_z = (-0,1, 0,1)
    # сделать домен
    домен = домен()
    # назад БК
    backBC = PointwiseBoundaryConstraint(
        узлы = узлы,
        геометрия=гео,
        outvar={"u": 0, "v": 0, "w": 0},
        batch_size=cfg.batch_size.backBC,
        lambda_weighting={"u": 10, "v": 10, "w": 10},
        критерии = Eq (х, support_origin [0]),
    )
    domain.add_constraint(backBC, "backBC")
    # передний БК
    frontBC = PointwiseBoundaryConstraint(
        узлы = узлы,
        геометрия=гео,
        outvar={"traction_x": 0, "traction_y": 0, "traction_z": T},
        batch_size=cfg. batch_size.frontBC,
        критерии = Eq (x, скобка_origin [0] + скобка_dim [0]),
    )
    domain.add_constraint(frontBC, "frontBC")
    # поверхность БК
    SurfaceBC = PointwiseBoundaryConstraint(
        узлы = узлы,
        геометрия=гео,
        outvar={"traction_x": 0, "traction_y": 0, "traction_z": 0},
        batch_size=cfg.batch_size.surfaceBC,
        критерии = (x > support_origin [0]) & (x < скобка_origin [0] + скобка_dim [0]),
    )
    domain.add_constraint(surfaceBC, "surfaceBC")
    # поддержка интерьера
    интерьер = точечное внутреннее ограничение (
        узлы = узлы,
        геометрия=гео,
        перевар={
            "равновесие_х": 0,0,
            "равновесие_у": 0,0,
            "равновесие_z": 0,0,
            "stress_disp_xx": 0.0,
            "stress_disp_yy": 0.0,
            "stress_disp_zz": 0.0,
            "stress_disp_xy": 0.0,
            "stress_disp_xz": 0.0,
            "stress_disp_yz": 0.0,
        },
        batch_size=cfg.batch_size.interior_support,
        bounds={x: bounds_support_x, y: bounds_support_y, z: bounds_support_z},
        lambda_weighting={
            «равновесие_x»: geo. sdf,
            «равновесие_у»: geo.sdf,
            «равновесие_z»: geo.sdf,
            "stress_disp_xx": гео.sdf,
            "stress_disp_yy": гео.sdf,
            "stress_disp_zz": гео.sdf,
            "stress_disp_xy": гео.sdf,
            "stress_disp_xz": гео.sdf,
            "stress_disp_yz": гео.sdf,
        },
    )
    domain.add_constraint(интерьер, "interior_support")
    # интерьер кронштейна
    интерьер = точечное внутреннее ограничение (
        узлы = узлы,
        геометрия=гео,
        перевар={
            "равновесие_х": 0,0,
            "равновесие_у": 0,0,
            "равновесие_z": 0,0,
            "stress_disp_xx": 0.0,
            "stress_disp_yy": 0.0,
            "stress_disp_zz": 0.0,
            "stress_disp_xy": 0.0,
            "stress_disp_xz": 0.0,
            "stress_disp_yz": 0.0,
        },
        batch_size=cfg.batch_size.interior_bracket,
        bounds={x: bounds_bracket_x, y: bounds_bracket_y, z: bounds_bracket_z},
        lambda_weighting={
            «равновесие_x»: geo. sdf,
            «равновесие_у»: geo.sdf,
            «равновесие_z»: geo.sdf,
            "stress_disp_xx": гео.sdf,
            "stress_disp_yy": гео.sdf,
            "stress_disp_zz": гео.sdf,
            "stress_disp_xy": гео.sdf,
            "stress_disp_xz": гео.sdf,
            "stress_disp_yz": гео.sdf,
        },
    )
    domain.add_constraint(внутренняя, "interior_bracket") 
         

Тренировочные ограничения состоят из двух разных наборов внутренних точек (т. е. interior_support и interior_bracket ). Это сделано только для более эффективного создания внутренних точек.

На рис. 52 показано результаты Modulus, а также сравнение с коммерческим решателем Результаты. Результаты этих двух решателей показывают хорошее согласие, только разница в максимальном смещении брекета составляет 8%.

Рис. 52. Результаты модуля линейной упругости для примера прогиба кронштейна

Задача 2: Анализ напряжений для панели фюзеляжа самолета

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

Рис. 53. Геометрия и граничные условия упрощенной панели фюзеляжа самолета.

Настройка корпуса и результаты

Материал панели — алюминий 2024-T3, с \((E, \nu) = (73 \,\text{ГПа}, 0,33)\). Мы обучаем параметризованный модель с переменным \(\sigma_{hoop} \in (46, 56.5)\). Поскольку толщина панели очень мала (т.е. \(2 \, \text{мм}\)), решить уравнения плоского напряжения в этом примере. Скрипт на питоне по этой проблеме можно найти на примера/fusselage_panel/panel_solver.py . Форма плоского напряжения уравнения линейной упругости в Modulus можно вызвать с помощью LinearElasticityPlaneStress класс:

Копия

Скопировано!

 
 # составить список узлов для развертывания графа
    le = LinearElasticityPlaneStress(лямбда_=лямбда_, мю=мю)
    эластичность_сеть = instanceate_arch(
        input_keys=[Ключ("x"), Ключ("y"), Ключ("sigma_hoop")],
        выходные_ключи = [
            Ключ("у"),
            Ключ("в"),
            Ключ("sigma_xx"),
            Ключ("sigma_yy"),
            Ключ("sigma_xy"),
        ],
        cfg=cfg.arch.full_connected,
    )
    узлы = le.make_nodes() + [
        elasticity_net.make_node(name="elasticity_network", jit=cfg.jit)
    ] 
         

На рис. 54 показано Результаты модуля для перемещений панели и напряжений. Для сравнения, результаты коммерческого решателя также представлены на рис. 55. Модуль и результаты коммерческого решателя близко согласуются, с разницей менее 5% при максимальном напряжении по фон Мизесу.

Рис. 54. Результаты линейной упругости модуля для примера панели фюзеляжа самолета с параметризованным кольцевым напряжением. Результаты для \(\sigma_{hoop}\) = 46

Рис. 55. Результаты линейной упругости коммерческого решателя для примера панели фюзеляжа самолета с \(\sigma_{hoop}\) = 46

Линейные уравнения упругости в вариационной форме

Помимо дифференциальной формы линейных уравнений упругости, Модуль также позволяет использовать вариационную форму этих уравнений. (Интерфейсная задача вариационным методом). В этом В разделе выводятся линейные уравнения упругости в вариационном форме, реализованной в Modulus. Мы будем использовать безразмерный переменные в этом выводе. Начните с формирования внутреннего продукта Уравнение (142) и векторный тест функция \(v \in \mathbf{V}\) и интегрирование по области, как следует

Используя интегрирование по частям, мы имеем

, где \(T_i\) — тяга. Первый член равен нулю для свободные от тяги границы. Уравнение (160) вариационная форма линейных уравнений упругости, принятая в Модуль. Член \(\hat{\sigma}_{ji}\) в этом уравнении вычисляется используя соотношение напряжение-смещение в уравнении (153).

Задача 3: Плоское смещение

В этом примере решается уравнение линейного упругого плоского напряжения в вариативной форме. Рассмотрим квадратную пластину, зажатую на одном конце и находится под граничным условием смещения на другом конце, как показано на рис. 56. Остальные границы без тяги. Предполагается, что свойства материала \((E, \nu) = (10 \,\text{МПа}, 0,2)\). Этот пример взят из ¹ .

Настройка случая и результаты

Чтобы решить эту задачу в вариационной форме, мы применяем граничные условия перемещений в дифференциальной форме, а также генерировать внутренние и граничные точки, которые будут использоваться при оценке интегралы в уравнении (160). Скрипт python для решения этой проблемы можно найти по адресу примеров/plane_displacement/plane_displacement. py .

Рис. 56Геометрия и граничные условия примера перемещения плоскости. Этот пример взят из ¹.

Копировать

Скопировано!

 
 # сделать домен
    домен = домен()
    bottomBC = PointwiseBoundaryConstraint(
        узлы = узлы,
        геометрия=гео,
        outvar={"u": 0.0, "v": 0.0},
        batch_size=cfg.batch_size.bottom,
        batch_per_epoch=5000,
        lambda_weighting={"u": 10,0, "v": 10,0},
        критерии = Eq (y, домен_происхождение [1]),
    )
    domain.add_constraint (нижний BC, "нижний BC_дифференциал")
    topBC = PointwiseBoundaryConstraint(
        узлы = узлы,
        геометрия=гео,
        outvar={"u": 0,0, "v": 0,1},
        batch_size=cfg.batch_size.top,
        batch_per_epoch=5000,
        lambda_weighting={"u": 10,0, "v": 10,0},
        критерии = Eq (y, domain_origin [1] + domain_dim [1])
        & (x <= domain_origin[0] + domain_dim[0] / 2.0),
    )
    domain.add_constraint(topBC, "topBC_дифференциал")
    # регистрируем вариационные данные
    пакет_за_эпоху = 1
    вариационные_наборы данных = {}
    # нижний BC, индекс : 0
    инвар = гео. sample_boundary(
        batch_per_epoch * cfg.batch_size.bottom,
        критерии = Eq (y, домен_происхождение [1]),
        квазислучайный = Истина,
    )
    invar["область"] *= batch_per_epoch
    Variational_datasets["bottom_bc"] = VariationalDataset(
        batch_size=cfg.batch_size.bottom,
        инвар = инвар,
        outvar_names=["u__x", "u__y", "v__x", "v__y"],
    )
    # topBC, индекс : 1
    инвар = гео.sample_boundary(
        batch_per_epoch * cfg.batch_size.top,
        критерии = Eq (y, domain_origin [1] + domain_dim [1])
        & (x <= domain_origin[0] + domain_dim[0] / 2.0),
        квазислучайный = Истина,
    )
    invar["область"] *= batch_per_epoch
    Variational_datasets["top_bc"] = VariationalDataset(
        batch_size=cfg.batch_size.top,
        инвар = инвар,
        outvar_names=["u__x", "u__y", "v__x", "v__y"],
    )
    # Интерьер, индекс : 2
    инвар = гео.sample_interior(
        batch_per_epoch * cfg.batch_size.interior,
        границы={х: границы_х, у: границы_у},
        квазислучайный = Истина,
    )
    invar["область"] *= batch_per_epoch
    Variational_datasets["interior"] = VariationalDataset(
        batch_size=cfg. batch_size.interior,
        инвар = инвар,
        outvar_names=["u__x", "u__y", "v__x", "v__y"],
    )
    # делаем вариационные ограничения
    вариационное_ограничение = вариационное ограничение (
        наборы данных = вариационные_наборы данных,
        узлы = узлы,
        количество_работников=1,
        потеря = DGLoss(),
    )
    domain.add_constraint(вариационное_ограничение, "вариационное") 
         

Граничные условия смещения были включены в обычная функция потери PINN. Для вариационных ограничений мы сначала создали VariationalDataset для каждого bc, указав инвар и необходимые outvar_names . Эти outvars затем будут использоваться при вычислении вариационных потерь. Затем создается VariationalConstraint с использованием словаря Variational_datasets и узлов сети. Для проигрыша укажите DGLoss() — пользовательская функция потерь, включающая вариационные потери. Остаток этого подраздела, рассказывается, как сгенерировать этот вариационный убыток ( DGLoss() ). Во-первых, прочитайте решение нейронной сети и градиенты внутри и граничные точки:

Копировать

Скопировано!

 
 класс DGLПотери(Потери):
    защита __init__(сам):
        супер().__инит__()
        test_fn = Test_Function(
            имя_ord_dict={
                Legendre_test: [k для k в диапазоне (10)],
                Trig_test: [k для k в диапазоне (10)],
            },
            коробка = [
                [домен_происхождение[0], домен_происхождение[1]],
                [домен_происхождение[0] + домен_dim[0], домен_происхождение[1] + домен_dim[1]],
            ],
            diff_list=["град"],
        )
        self.v = Vector_Test (test_fn, test_fn, смесь = 0,02)
    вперед вперед(
        себя,
        список_инвар,
        list_outvar,
        шаг: интервал,
    ):
        torch.cuda.nvtx.range_push("Make_DGLoss")
        torch.cuda.nvtx.range_push("Make_DGLoss_Get_Data")
        # self.v.sample_vector_test()
        # получить очки на интерьере
        x_interior = list_invar[2]["x"]
        y_interior = list_invar[2]["y"]
        area_interior = list_invar[2]["область"]
        # вычислительное решение для интерьера
        u_x_interior = list_outvar[2]["u__x"]
        u_y_interior = list_outvar[2]["u__y"]
        v_x_interior = list_outvar[2]["v__x"]
        v_y_interior = list_outvar[2]["v__y"]
        # получить очки на границе
        x_bottom_dir = list_invar[0]["x"]
        y_bottom_dir = list_invar[0]["y"]
        normal_x_bottom_dir = list_invar[0]["normal_x"]
        normal_y_bottom_dir = list_invar[0]["normal_y"]
        area_bottom_dir = list_invar[0]["область"]
        x_top_dir = list_invar[1]["x"]
        y_top_dir = list_invar[1]["y"]
        normal_x_top_dir = list_invar[1]["normal_x"]
        normal_y_top_dir = list_invar[1]["normal_y"]
        area_top_dir = list_invar[1]["область"]
        # вычислить решение для границы
        u_x_bottom_dir = list_outvar[0]["u__x"]
        u_y_bottom_dir = list_outvar[0]["u__y"]
        v_x_bottom_dir = list_outvar[0]["v__x"]
        v_y_bottom_dir = list_outvar[0]["v__y"]
        u_x_top_dir = list_outvar[1]["u__x"]
        u_y_top_dir = list_outvar[1]["u__y"]
        v_x_top_dir = list_outvar[1]["v__x"]
        v_y_top_dir = list_outvar[1]["v__y"]
        факел. cuda.nvtx.range_pop()
        torch.cuda.nvtx.range_push("Make_DGLoss_Test_Function") 
         

На следующем шаге определите тестовые функции и вычислите тест функции и их требуемые градиенты внутри и на границе очки:

Копировать

Скопировано!

 
 # тестовые функции
        vx_x_interior, vy_x_interior = self.v.eval_test("vx", x_interior, y_interior)
        vx_y_interior, vy_y_interior = self.v.eval_test("vy", x_interior, y_interior)
        vx_bottom_dir, vy_bottom_dir = self.v.eval_test("v", x_bottom_dir, y_bottom_dir)
        vx_top_dir, vy_top_dir = self.v.eval_test("v", x_top_dir, y_top_dir) 
         

Здесь набор тестовых функций, состоящий из Лежандра построены полиномы и тригонометрические функции, а 2% эти тестовые функции выбираются случайным образом. Вычислять только члены, которые появляются в вариационные потери в уравнении (160). Для Например, нет необходимости вычислять производную теста функции относительно входных координат граничных точек.

Следующим шагом является вычисление условий напряжения в соответствии с плоскостью уравнения напряжения в уравнениях (157), (158), а также тяга термины:

Копировать

Скопировано!

 
 факел.cuda.nvtx.range_pop()
        torch.cuda.nvtx.range_push("Make_DGLoss_Computation")
        w_z_interior = -lambda_/(lambda_+2*mu)*(u_x_interior+v_y_interior)
        sigma_xx_interior = (
            lambda_ * (u_x_interior + v_y_interior + w_z_interior)
            +2*мю*у_х_интерьер
        )
        sigma_yy_interior = (
            lambda_ * (u_x_interior + v_y_interior + w_z_interior)
            +2*мю*в_у_интерьер
        )
        sigma_xy_interior = mu * (u_y_interior + v_x_interior)
        w_z_bottom_dir = (
            -лямбда_ / (лямбда_ + 2 * мю) * (u_x_нижний_каталог + v_y_нижний_каталог)
        )
        sigma_xx_bottom_dir = (
            lambda_ * (u_x_bottom_dir + v_y_bottom_dir + w_z_bottom_dir)
            + 2 * мю * u_x_bottom_dir
        )
        sigma_yy_bottom_dir = (
            lambda_ * (u_x_bottom_dir + v_y_bottom_dir + w_z_bottom_dir)
            + 2 * мю * v_y_bottom_dir
        )
        sigma_xy_bottom_dir = mu * (u_y_bottom_dir + v_x_bottom_dir)
        w_z_top_dir = -lambda_/(lambda_ + 2 * mu) * (u_x_top_dir + v_y_top_dir)
        sigma_xx_top_dir = (
            lambda_ * (u_x_top_dir + v_y_top_dir + w_z_top_dir) + 2 * mu * u_x_top_dir
        )
        sigma_yy_top_dir = (
            lambda_ * (u_x_top_dir + v_y_top_dir + w_z_top_dir) + 2 * mu * v_y_top_dir
        )
        sigma_xy_top_dir = mu * (u_y_top_dir + v_x_top_dir)
        traction_x_bottom_dir = (
            sigma_xx_bottom_dir * нормальный_x_bottom_dir
            + sigma_xy_bottom_dir * нормальный_y_bottom_dir
        )
        traction_y_bottom_dir = (
            sigma_xy_bottom_dir * нормальный_x_bottom_dir
            + sigma_yy_bottom_dir * нормальный_y_bottom_dir
        )
        traction_x_top_dir = (
            sigma_xx_top_dir * normal_x_top_dir + sigma_xy_top_dir * normal_y_top_dir
        )
        traction_y_top_dir = (
            sigma_xy_top_dir * normal_x_top_dir + sigma_yy_top_dir * normal_y_top_dir
        ) 
         

Наконец, следуя уравнению (160), определить ваши вариационные внутренние и граничные интегральные члены, сформулировать вариационные потери и добавьте их к общим потерям следующим образом:

Копия

Скопировано!

 факел. cuda.nvtx.range_pop()
 torch.cuda.nvtx.range_push("Make_DGLoss_Integral")
 внутренняя_потеря = tensor_int(
 площадь_интерьер,
 sigma_xx_interior * vx_x_interior
 + sigma_yy_interior * vy_y_interior
 + sigma_xy_interior * (vx_y_interior + vy_x_interior),
 )
 border_loss1 = tensor_int(
 область_нижний_каталог,
 traction_x_bottom_dir * vx_bottom_dir
 + traction_y_bottom_dir * vy_bottom_dir,
 )
 border_loss2 = tensor_int(
 area_top_dir,
 traction_x_top_dir * vx_top_dir + traction_y_top_dir * vy_top_dir,
 )
 факел.cuda.nvtx.range_pop()
 torch.cuda.nvtx.range_push("Make_DGLoss_Register_Loss")
 потери = {
 "variational_plane": torch.abs(
 внутренняя_потеря - граница_потери1 - граница_потери2
 )
 .pow(2)
 .сумма()
 }
 факел.cuda.nvtx.range_pop()
 факел.
No related posts.