Logo GenDocs.ru

Поиск по сайту:  


Загрузка...

Оптимизация параметров листовой рессоры методом градиентного спуска - файл Оформление.doc


Оптимизация параметров листовой рессоры методом градиентного спуска
скачать (238 kb.)

Доступные файлы (1):

Оформление.doc27563kb.18.02.2011 17:36скачать

Загрузка...

Оформление.doc

Реклама MarketGid:
Загрузка...
Министерство образования и науки Российской Федерации
Государственное образовательное учреждение

высшего профессионального образования
«Южно–Уральский государственный университет»

Кафедра “Автомобили”


КУРСОВОЙ ПРОЕКТ

По дисциплине: «Системы автоматизированного проектирования»
На тему: «Оптимизация параметров листовой рессоры»


Выполнил: студент группы АТ-531

Филин А.А.

Проверил:

Губарев А.В.

Челябинск 2010

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

Блок-схема




Алгоритм реализован в программной среде С++
//---------------------------------------------------------------------------

#pragma hdrstop

#include<stdio.h>

#include<conio.h>

#include<math.h>

//---------------------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])

{float bn0=0.1;

float hn0=0.015;

float Ln0=1.5;

float in0=10;

float in=10;

float m0=32001;

float m=31000;

float mn=31001;

float fst,sigma, sigma0,b,h,L,i,di,db,dh,dL,bn,hn,Ln,i0,b0,h0,L0, fst0,mi1,mi2,mb1,mb2,mh1,mh2,mL1,mL2;

float E= 2*pow10(8);

int Pst=5050;

int p=7800;

int k=pow10(3);

float fp=0.315;

float r=0.000001;

while(in>1)

{bn=bn0; hn=hn0; Ln=Ln0; in=in0; mn=m+1;

while(m<mn)

{ b=bn; h=hn; L=Ln; i=in;

fst=Pst*pow(L,3)/(i*b*E*pow(h,3));

sigma=1.5*fp*Pst*L/(fst*i*b*pow(h,2));

m=0.5*i*b*h*L*p;

mi1=0.5*(i-r)*b*h*L*p; mi2=0.5*(i+r)*b*h*L*p; mb1=0.5*i*(b-r)*h*L*p; mb2=0.5*i*(b+r)*h*L*p;

mh1=0.5*i*b*(h-r)*L*p; mh2=0.5*i*b*(h+r)*L*p; mL1=0.5*i*b*h*(L-r)*p; mL2=0.5*i*b*h*(L+r)*p;

if (sigma>9*pow10(8))

{m=m+(sigma-9*pow10(8))*k;

mi1=mi1+(sigma-9*pow10(8))*k; mi2=mi2+(sigma-9*pow10(8))*k;

mb1=mb1+(sigma-9*pow10(8))*k; mb2=mb2+(sigma-9*pow10(8))*k;

mh1=mh1+(sigma-9*pow10(8))*k; mh2=mh2+(sigma-9*pow10(8))*k;

mL1=mL1+(sigma-9*pow10(8))*k; mL2=mL2+(sigma-9*pow10(8))*k;}

if(fst>0.225)

{m=m+(fst-0.225)*k;

mi1=mi1+(fst-0.225)*k; mi2=mi2+(fst-0.225)*k; mb1=mb1+(fst-0.225)*k; mb2=mb2+(fst-0.225)*k;

mh1=mh1+(fst-0.225)*k; mh2=mh2+(fst-0.225)*k; mL1=mL1+(fst-0.225)*k; mL2=mL2+(fst-0.225)*k;}

if(fst<0.175)

{m=m+(0.175-fst)*k;

mi1=mi1+(0.175-fst)*k; mi2=mi2+(0.175-fst)*k; mb1=mb1+(0.175-fst)*k; mb2=mb2+(0.175-fst)*k;

mh1=mh1+(0.175-fst)*k; mh2=mh2+(0.175-fst)*k; mL1=mL1+(0.175-fst)*k; mL2=mL2+(0.175-fst)*k;}

if(i>10)

{m=m+(i-10)*k;

mi1=mi1+(i-10)*k; mi2=mi2+(i-10)*k; mb1=mb1+(i-10)*k; mb2=mb2+(i-10)*k;

mh1=mh1+(i-10)*k; mh2=mh2+(i-10)*k; mL1=mL1+(i-10)*k; mL2=mL2+(i-10)*k;}

if(b>0.1)

{m=m+(b-0.1)*k;

mi1=mi1+(b-0.1)*k; mi2=mi2+(b-0.1)*k; mb1=mb1+(b-0.1)*k; mb2=mb2+(b-0.1)*k;

mh1=mh1+(b-0.1)*k; mh2=mh2+(b-0.1)*k; mL1=mL1+(b-0.1)*k; mL2=mL2+(b-0.1)*k;}

if(b<0.03)

{m=m+(0.03-b)*k;

mi1=mi1+(0.03-b)*k; mi2=mi2+(0.03-b)*k; mb1=mb1+(0.03-b)*k; mb2=mb2+(0.03-b)*k;

mh1=mh1+(0.03-b)*k; mh2=mh2+(0.03-b)*k; mL1=mL1+(0.03-b)*k; mL2=mL2+(0.03-b)*k;}

if(h<0.001)

{m=m+(0.001-h)*k;

mi1=mi1+(0.001-h)*k; mi2=mi2+(0.001-h)*k; mb1=mb1+(0.001-h)*k; mb2=mb2+(0.001-h)*k;

mh1=mh1+(0.001-h)*k; mh2=mh2+(0.001-h)*k; mL1=mL1+(0.001-h)*k; mL2=mL2+(0.001-h)*k;}

if(h>0.015)

{m=m+(0.015-h)*k;

mi1=mi1+(0.015-h)*k; mi2=mi2+(0.015-h)*k; mb1=mb1+(0.015-h)*k; mb2=mb2+(0.015-h)*k;

mh1=mh1+(0.015-h)*k; mh2=mh2+(0.015-h)*k; mL1=mL1+(0.015-h)*k; mL2=mL2+(0.015-h)*k;}

if(L>1.5)

{m=m+(L-1.5)*k;

mi1=mi1+(L-1.5)*k; mi2=mi2+(L-1.5)*k; mb1=mb1+(L-1.5)*k; mb2=mb2+(L-1.5)*k;

mh1=mh1+(L-1.5)*k; mh2=mh2+(L-1.5)*k; mL1=mL1+(L-1.5)*k; mL2=mL2+(L-1.5)*k; }

if(L<0.3)

{m=m+(0.3-L)*k;

mi1=mi1+(0.3-L)*k; mi2=mi2+(0.3-L)*k; mb1=mb1+(0.3-L)*k; mb2=mb2+(0.3-L)*k;

mh1=mh1+(0.3-L)*k; mh2=mh2+(0.3-L)*k; mL1=mL1+(0.3-L)*k; mL2=mL2+(0.3-L)*k;}

if(mi1<mi2)

{di=0.5*(mh2-mh1)/r;}

else

{di=-0.5*(mh2-mh1)/r;}

if(mb1<mb2)

{db=0.5*(mh2-mh1)/r;}

else

{db=-0.5*(mh2-mh1)/r;}

if(mh1<mh2)

{dh=0.5*(mh2-mh1)/r;}

else

{dh=-0.5*(mh2-mh1)/r;}

if(mL1<mL2)

{dL=0.5*(mh2-mh1)/r;}

else

{dL=-0.5*(mh2-mh1)/r;}

in=i-di; bn=b-db; hn=h-dh; Ln=L-dL;

if(m<mn)

{mn=m; m=m-1;}

else

{if(mn<m0)

{m0=mn; i0=in; b0=bn; h0=hn; L0=Ln; fst0=fst; sigma0= sigma;}

if(Ln0==0.3)

{Ln0=1.5; hn0=0.015; bn0=bn0-0.01;

if(bn0==0.03)

{bn0=0.1; in0=in0+1;}}}

else

{Ln0=Ln0-0.01; mn=m-1;}}}}

printf("i=%0, WT\n", i0); printf("b=%0*.*f, mm\n",0,3, b0*1000);

printf("h=%0*.*f, mm\n",0,3, h0*1000); printf("L=%0*.*f, mm\n",0,3, L0*1000);

printf("m=%0*.*f, kg\n",0,3, m0); printf("sigma=%0*.*f, Mn\n",0,3, sigma0/1000000);

printf("fst=%0*.*f, mm\n",0,3, fst0*1000);

getch();

return 0;
Результаты расчёта



Окончательные значения параметров выбираем конструктивно:

i=3 шт, b=iּb/iприн, b=83 мм, h=6 мм, L=794 мм.
Для сравнения полученных результатов

выполним оптимизацию методом Гаусса

ib

h

L

m,кг

σ, Мпа

fст, м

1

0,01

1,5

58,5

420

0,085219

0,95

0,01

1,5

55,575

420

0,089704

0,45

0,01

1,5

26,325

420

0,189375

0,4

0,01

1,5

23,4

420

0,213047

0,4

0,01

1,49

23,244

425,6565

0,208814

0,4

0,01

1,39

21,684

489,10512

0,16953

0,4

0,01

1,38

21,528

496,21928

0,165897

0,4

0,009

1,38

19,3752

446,59735

0,227568

0,4

0,009

1,37

19,2348

453,14082

0,222657

0,4

0,009

1,25

17,55

544,32

0,169123

0,4

0,009

1,24

17,4096

553,13476

0,165097

0,4

0,008

1,24

15,4752

491,67534

0,23507

0,4

0,008

1,23

15,3504

499,70256

0,229428

0,4

0,008

1,22

15,2256

507,92798

0,223878

0,4

0,008

1,12

13,9776

602,67857

0,173215

0,4

0,008

1,11

13,8528

613,58656

0,168617

0,38

0,008

1,11

13,16016

613,58656

0,177491

0,36

0,008

1,11

12,46752

613,58656

0,187352

0,34

0,008

1,11

11,77488

613,58656

0,198372

0,32

0,008

1,11

11,08224

613,58656

0,210771

0,32

0,008

1,1

10,9824

624,79339

0,205125

0,32

0,008

1,04

10,38336

698,9645

0,173357

0,32

0,008

1,03

10,28352

712,60251

0,168404

0,32

0,007

1,03

8,99808

623,52719

0,251379

0,32

0,007

1,02

8,91072

635,81315

0,244128

0,32

0,007

0,91

7,94976

798,81657

0,173357

0,32

0,007

0,9

7,8624

816,66667

0,167705

0,32

0,006

0,9

6,7392

700

0,266309

0,32

0,006

0,89

6,66432

715,81871

0,25753

0,32

0,006

0,8

5,9904

885,9375

0,187037

0,32

0,006

0,79

5,91552

908,50825

0,18011

0,32

0,005

0,79

4,9296

757,09021

0,311231

0,32

0,005

0,78

4,8672

776,62722

0,299561

0,32

0,005

0,77

4,8048

796,93034

0,288186

0,32

0,005

0,74

4,6176

862,8561

0,255798

0,32

0,005

0,73

4,5552

886,65791

0,245567

0,325

0,005

0,73

4,626375

886,65791

0,241789

0,36

0,005

0,73

5,1246

886,65791

0,218282

0,365

0,005

0,73

5,195775

886,65791

0,215292

0,365

0,005

0,73

5,195775

886,65791

0,215292

0,365

0,005

0,729

5,188658

889,09211

0,214408

0,365

0,005

0,726

5,167305

896,45516

0,211772

0,365

0,005

0,725

5,160188

898,92985

0,210898


Принимаемые значения параметров:

i=5 шт, b=73 мм, h=5 мм, L=725 мм.

Для проверки полученных результатов

выполним оптимизацию перебором

Алгоритм реализован в программной среде С++
//---------------------------------------------------------------------------

#pragma hdrstop

#include<stdio.h>

#include<conio.h>

#include<math.h>

//---------------------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])

{int i=10;

int i0;

float b=0.1;

float h=0.015;

float L=1.5;

float sigma,sigma0;

float m0=1000;

float fst,b0,h0,L0,fst0,m;

float E=2*pow10(11);

int Pst=5050; int p=7800; float fp=0.315;

while(i>=1)

{

fst=Pst*pow(L,3)/(i*b*E*pow(h,3));

sigma=1.5*fp*Pst*L/(fst*i*b*h*h);

m=0.5*i*b*h*L*p;
if(m<m0) {if(sigma<9*pow10(8)) {if(fst<0.235) {if(fst>0.185)

{m0=m; i0=i; h0=h; b0=b; L0=L; fst0=fst; sigma0=sigma;}}}}

if(L>0.5)

{L=L-0.001;}

else

{L=1.5; h=h-0.001;

if(h<0.002)

{h=0.015; b=b-0.001;

if(b<0.03)

{b=0.1; i=i-1;}}}}

printf("i=%i, WT\n", i0); printf("b=%0*.*f, mm\n",0,0, b0*1000);

printf("h=%0*.*f, mm\n",0,0, h0*1000); printf("L=%0*.*f, mm\n",0,0, L0*1000);

printf("m=%0*.*f, kg\n",0,3, m0); printf("sigma=%0*.*f, Mn\n",0,0, sigma0/1000000);

printf("fst=%0*.*f, mm\n",0,3, fst0*1000);

getch();

return 0;}
Результаты расчёта


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

i=3 шт, b=83 мм, h=6 мм, L=794 мм.


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

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


Скачать файл (238 kb.)

Поиск по сайту:  

© gendocs.ru
При копировании укажите ссылку.
обратиться к администрации
Рейтинг@Mail.ru