Читать онлайн «Расчет рам и платформ на нагрузку, перпендикулярную плоскости рамы», Константин Владимирович Ефанов – Литрес

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

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

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

На современной уровне расчеты выполняют методом конечных элементов в специальных компьютерных программах. Строительные конструкции рассчитывают в программах lira, SCAD, Robot и др. В этих же программах можно заложить плоскую раму и выполнит её расчет, но только для рам КМ (конструкций металлических), сваренных из металлопроката. Расчет машиностроительных изделий МКЭ выполняется в программах МКЭ таких как Ansys, SolidWorks Simulation и др. Для расчета таких рам, как рамы платформ, решетки катализатора лучше применять программы МКЭ, предназначенные для расчета машиностроительных изделий. Рама решетки катализатора имеет поперечные балки с прорезями, в которые устанавливаются продольные балки, и такую раму лучше рассчитывать в МКЭ типа Ansys или вручную методом строительной механики (методом сил) или упрощенно методом сопротивления материалов (просто расчет балок на изгиб).

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

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

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

Для решеток катализатора расчет заключается в расчете:

– несущих балок на изгиб и кручение с проверкой условия прочности по теории энергетической теории прочности, опирающихся на пояс, приваренный изнутри к обечайке корпуса аппарата;

– решеток катализатора, опирающихся на несущие балки, на которые опирается сетка Джонсона;

– расчете прутьев сетки Джонсона, на которой находится катализатор (или непосредственно или сначала фарфоровые шары для выравнивания потока среды через катализатор).

Для несущих платформ блоков нефтяных аппаратов нагрузка на раму передается при подъеме за строповые устройства от установленного оборудования. Для железнодорожных платформ нагрузка на раму передаётся непосредственно от груза.

Для рам блоков нефтяных аппаратов существует методика расчета рамы по РД 26-18-7-88. Эта методика уступает методике расчета, приведенной в настоящей книге за счет упрощений состоящим в отдельных расчетах на изгиб продольных балок и последующих расчетах поперечных балок.

Расчет несущих балок выполняется методом сопротивления материалов на основании работы [1] (эта работа является лучшим учебником сопромата с изложением расчета балок и рам). Расчет решеток катализатора является наиболее сложной задачей и выполняется с использованием теории [2] и [3] по примерам, приведенным в работах [4] [5] для железнодорожных платформ, где эти расчеты разработаны в отличии от рам в аппаратах нефтепереработки. Но расчет решеток может быть выполнен упрощенно в случае отсутствия знания строительной механики. Расчет прутьев сетки Джонсона выполняется по модели многопролетной балки по теореме трех моментов по работам [1] и [2].

Данные графического датчика с Python и Matplotlib

Авторы: Шон Хаймел

Избранное Любимый 14

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

Код анимации

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

 язык: python
импортировать дату и время как dt
импортировать matplotlib.  pyplot как plt
импортировать matplotlib.animation как анимацию
импортировать tmp102
# Создаем фигуру для построения
рис = plt.figure()
топор = fig.add_subplot (1, 1, 1)
хз = []
да = []
# Инициализировать связь с TMP102
tmp102.init()
# Эта функция периодически вызывается из FuncAnimation
определение анимации (i, xs, ys):
    # Чтение температуры (по Цельсию) из TMP102
    temp_c = раунд (tmp102.read_temp(), 2)
    # Добавляем x и y в списки
    xs.append(dt.datetime.now().strftime('%H:%M:%S.%f'))
    ys.append(temp_c)
    # Ограничение списков x и y до 20 элементов
    хз = хз[-20:]
    да = да [-20:]
    # Нарисовать списки x и y
    топор.очистить()
    ax.plot (xs, ys)
    # Формат графика
    plt.xticks (поворот = 45, га = «право»)
    plt.subplots_adjust (внизу = 0,30)
    plt.title('Температура TMP102 в зависимости от времени')
    plt.ylabel('Температура (градусы C)')
# Настроить график для периодического вызова функции animate()
ani = анимация.FuncAnimation(fig, animate, fargs=(xs, ys), interval=1000)
plt.
  show()
 

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

Код для заметки

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

Внизу кода вы увидите секретный соус к анимации:

ani = animation.FuncAnimation(fig, animate, fargs=(xs, ys), interval=1000)

FuncAnimation — это специальная функция в модуле анимации , позволяющая автоматизировать обновление графика. Мы передаем FuncAnimation() дескриптор фигуры, которую хотим нарисовать, fig , а также имя функции, которая должна вызываться через равные промежутки времени. Мы назвали эту функцию animate() и она определена чуть выше нашего 9. 0021 Вызов FuncAnimation() .

По-прежнему в параметрах FuncAnimation() мы устанавливаем fargs , которые являются аргументами, которые мы хотим передать нашей функции animate (поскольку мы не вызываем animate() непосредственно из нашего собственного кода) . Затем мы устанавливаем интервал , который показывает, как долго мы должны ждать между вызовами animate() (в миллисекундах).

Примечание: В качестве аргумента FuncAnimation обратите внимание, что animate не имеет скобок. Это передача ссылки функции, а не результата этой функции. Если вы случайно добавите здесь круглые скобки для анимации, анимация будет вызвана немедленно (только один раз), и вы, вероятно, получите сообщение об ошибке (вероятно, что-то о кортеже, который нельзя вызвать)!

Если вы посмотрите на вызов animate() , вы увидите, что он имеет 3 параметра, которые мы определили:

def animate(i, xs, ys):

i — номер кадра. Этот параметр необходим при определении функции для FuncAnimation . Всякий раз, когда вызывается animate() , i будет автоматически увеличиваться на 1. xs и ys — это наши списки, содержащие метку времени и значения температуры соответственно. Мы сказали FuncAnimation() , что хотим передать xs и ys с параметром fargs . Не говоря явно, что мы хотим xs и ys в качестве параметров, нам нужно будет использовать глобальные переменные для запоминания значений в xs и ys .

В animate() мы собираем данные о температуре и добавляем метку времени, как и в предыдущем примере. Мы также усекаем как xs , так и ys , чтобы каждый из них был ограничен 20 элементами. Если бы мы позволили спискам расти бесконечно, временные метки было бы трудно читать, и мы в конечном итоге использовали бы нашу память.

Чтобы нарисовать график, мы должны очистить оси с помощью ax.clear() , а затем построить линию с помощью ax.plot() . Если бы мы не очищали их каждый раз, графики просто накладывались бы друг на друга, и весь график был бы в беспорядке. Точно так же нам нужно переформатировать график для каждого кадра.

Вы могли заметить, что график обновляется только один раз в секунду (как определено interval=1000 ). Для некоторых датчиков, таких как датчик температуры, это достаточно быстро. На самом деле, вы можете измерять температуру только один раз в минуту, час или даже день. Однако эта частота выборки может быть слишком низкой для других датчиков, таких как датчики расстояния или акселерометры, где вашему приложению требуются обновления каждые несколько миллисекунд.

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

---

python — Как обновить график в matplotlib

спросил 12 лет, 5 месяцев назад

Изменено 1 год, 4 месяца назад

Просмотрено 566 тысяч раз

У меня проблемы с перерисовкой рисунка здесь. Я разрешаю пользователю указывать единицы измерения по шкале времени (ось X), а затем пересчитываю и вызываю эту функцию plots() . Я хочу, чтобы сюжет просто обновлялся, а не добавлял к рисунку еще один сюжет.

 по умолчанию графики():
    глобальный vlgaBuffSorted
    центр()
    результат = collections.defaultdict (список)
    для d в vlgaBuffSorted:
        результат[d['событие']]. append(d)
    список_результатов = результат.значения()
    f = Фигура()
    график2 = f.add_subplot(211)
    graph3 = f.add_subplot(212,sharex=graph2)
    для элемента в result_list:
        tL = []
        vgsL = []
        vdsL = []
        isubL = []
        для dict в элементе:
            tL.append(dict['время'])
            vgsL.append(dict['vgs'])
            vdsL.append(dict['vds'])
            isubL.append(dict['isub'])
        graph2.plot(tL,vdsL,'bo',label='a')
        graph2.plot(tL,vgsL,'rp',label='b')
        graph3.plot(tL,isubL,'b-',label='c')
    plotCanvas = FigureCanvasTkAgg(f, pltFrame)
    панель инструментов = NavigationToolbar2TkAgg (plotCanvas, pltFrame)
    toolbar.pack(сторона=НИЗ)
    plotCanvas.get_tk_widget().pack(сторона=ВЕРХ)
 

• питон
• матплотлиб
• ткинтер

2

По сути, у вас есть два варианта:

1. Делайте то же, что и сейчас, но вызывайте graph2. clear() и graph3.clear() перед повторным построением данных. Это самый медленный, но самый простой и надежный вариант.

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

Чтобы привести пример второго варианта:

 импортировать matplotlib.pyplot как plt
импортировать numpy как np
х = np.linspace (0, 6 * np.pi, 100)
у = np.sin (х)
# Вероятно, вам это не понадобится, если вы встраиваете что-то в сюжет tkinter...
плт.ион()
рис = plt.figure()
топор = fig.add_subplot(111)
line1, = ax.plot(x, y, 'r-') # Возвращает кортеж линейных объектов, поэтому запятая
для фазы в np.linspace(0, 10*np.pi, 500):
    line1.set_ydata(np.sin(x + фаза))
    fig. canvas.draw()
    fig.canvas.flush_events()
 

9

Вы также можете сделать следующее: Это нарисует случайные матричные данные 10×1 на графике для 50 циклов цикла for.

 импортировать matplotlib.pyplot как plt
импортировать numpy как np
плт.ион()
для я в диапазоне (50):
    у = np.random.random ([10,1])
    plt.plot(y)
    plt.draw()
    пл.пауза(0,0001)
    plt.clf()
 

5

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

 импортировать matplotlib.pyplot как plt
импортировать matplotlib.animation как анимацию
def plot_cont (весело, xmax):
    у = []
    рис = plt.figure()
    топор = fig.add_subplot (1,1,1)
    обновление защиты (я):
        уи = весело ()
        y.append(yi)
        х = диапазон (длина (у))
        топор.очистить()
        ax.plot (х, у)
        напечатать i, ': ', yi
    a = anim. FuncAnimation (рис., обновление, кадры = xmax, повтор = False)
    plt.show()
 

«fun» — это функция, возвращающая целое число. FuncAnimation будет неоднократно вызывать «обновление», оно будет делать это «xmax» раз.

3

Это сработало для меня:

 из matplotlib импортировать pyplot как plt
из IPython.display импортировать clear_output
импортировать numpy как np
для я в диапазоне (50):
    clear_output (ожидание = Истина)
    у = np.random.random ([10,1])
    plt.plot(y)
    plt.show()
 

3

Я выпустил пакет под названием python-drawnow, который обеспечивает функциональность, позволяющую обновлять фигуру, обычно вызываемую в цикле for, подобно Matlab 9.0021 нарисовано .

Пример использования:

 из pylab импортировать фигуру, график, ион, linspace, arange, sin, pi
определение draw_fig():
    # может быть произвольно сложным; просто нарисовать фигуру
    #figure() # не звонить!
    график (т, х)
    #show() # не звонить!
N = 1e3
Figure() # вместо этого позвоните сюда!
ion() # включить интерактивность
t = линейное пространство (0, 2 * пи, число = N)
для i в диапазоне (100):
    х = грех (2 * пи * я ** 2 * т / 100,0)
    нарисовано(draw_fig)
 

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

2

Если кто-то наткнется на эту статью в поисках того, что я искал, я нашел примеры по адресу

Как визуализировать скалярные 2D-данные с помощью Matplotlib?

и

http://mri.brechmos.org/2009/07/automatically-update-a-figure-in-a-loop (на web.archive.org)

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

---

Начиная с трехмерного массива изображений формы (nBins, nBins, nBins), называемых кадрами .

 по определению animate_frames (кадры):
    nBins = кадры.форма[0]
    кадр = кадры[0]
    tempCS1 = plt.imshow (кадр, cmap = plt.cm.gray)
    для k в диапазоне (nBins):
        кадр = кадры [k]
        tempCS1 = plt.imshow (кадр, cmap = plt.cm.gray)
        удалить tempCS1
        fig.canvas.draw()
        #time.sleep(1e-2) #ненужно, но полезно
        рис.clf()
рис = plt.figure()
топор = fig.  add_subplot(111)
выигрыш = fig.canvas.manager.window
fig.canvas.manager.window.after(100, animate_frames, кадры)
 

Я также нашел гораздо более простой способ выполнить весь этот процесс, хотя и менее надежный:

 fig = plt.figure()
для k в диапазоне (nBins):
    plt.clf()
    plt.imshow (кадры [k], cmap = plt.cm.gray)
    fig.canvas.draw()
    time.sleep(1e-6) #ненужный, но полезный
 

Обратите внимание, что оба они работают только с

ipython --pylab=tk , он же backend = TkAgg

Спасибо за помощь во всем.

Все вышесказанное может быть правдой, однако для меня «онлайн-обновление» цифр работает только с некоторыми бэкендами, а именно с wx . Вы просто можете попробовать изменить это, например. запустив ipython/pylab с помощью ipython --pylab=wx ! Удачи!

2

Основываясь на других ответах, я обернул обновление фигуры в декоратор Python, чтобы отделить механизм обновления графика от фактического графика.