Автоколебания в химических реакциях. Численные методы

Размещено на http://www.allbest.ru//

Размещено на http://www.allbest.ru//

МОСКОВСКИЙ ЭНЕРГЕТИЧЕСКИЙ ИНСТИТУТ

(ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ)

Курсовая работа

Автоколебания в химических реакциях. Численные методы

Выполнил:

студент группы А-13-08

кафедры ПМ

Захаров Антон

Преподаватель:

Вестфальский

Алексей Евгеньевич

Москва, 2011 г



Постановка задачи

Автоколебания в химических реакциях

Модель Лефевра-Николиса описывает колебательные процессы в следующей цепочке химических реакций:

Предполагается, что концентрации веществ A, B, D, E остаются постоянными и все реакции необратимы. Тогда изменение концентрации x и y реагентов X и Y будет описываться следующей системой ОДУ:

Здесь a и b- концентрации исходных веществ A и B соответственно.

Вывести расчётные формулы метода Рунге-Кутты 3-го порядка точности с параметрами.

С помощью построенного метода найти численное решение задачи Коши при различных начальных данных и различных значениях коэффициентов.

Вывести графики зависимости решения и,а также фазовый портрет (в переменных x, y). Также обозначить на графиках стационарное решение (особые точки). автоколебание график химический численный

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

Вывод расчётных формул

Выведем расчётные формулы метода Рунге-Кутты 3-го порядка точности с параметрами.

Введём на отрезке три вспомогательных узла:

Заметим, что , так как и , так как .

Заменим, входящий в равенство интеграл квадратурной суммой с узлами :

Нам неизвестны значения и . Чтобы найти их запишем равенства:

Ещё раз заменяем интегралы квадратурными суммами:

Пусть -приближение к значению углового коэффициента в точке , тогда

Расчётные формулы метода Рунге-Кутты 3-го порядка точности:

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

Параметрами этого метода являются величины Представим погрешность аппроксимации:

(где - решение дифференциального уравнения ) в виде разложения по степеням h.

Формула Тейлора:

с учётом равенств

даёт формулу

Представим значения функций, используя формулу Тейлора для функции двух переменных с центром в точке :

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

Если потребовать, чтобы выполнялись условия:

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

Тестовые примеры

Пример 1.

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

Результаты работы программы (приложение к курсовой работе):



Пример 2.

В данном примере рассмотрим состояние равновесия

, отвечающее стационарному протеканию химической реакции, когда концентрации реагирующих веществ постоянны.

Результаты работы программы (приложение к курсовой работе):



Исходные коды программы



MainUnit.h

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

#ifndefMainUnitH

#define MainUnitH

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

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <ComCtrls.hpp>

#include <Grids.hpp>

#include <vector.h>

#include "sSkinManager.hpp"

#include "sLabel.hpp"

#include "sBitBtn.hpp"

#include <Buttons.hpp>

#include "sGroupBox.hpp"

#include "sCheckBox.hpp"

#include "sPanel.hpp"

#include <ExtCtrls.hpp>

#include "sSkinProvider.hpp"

#include "sUpDown.hpp"

#include "sPageControl.hpp"

#include "Common.h"

#include "sColorSelect.hpp"

#include "sSpeedButton.hpp"

#include "acPNG.hpp"

#include "sTrackBar.hpp"

#include "sRadioButton.hpp"

#include "sStatusBar.hpp"

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

classTMainForm : public TForm

{

__published:

TsSkinManager *sSkinManager1;

TsSkinProvider *sSkinProvider1;

TsStatusBar *sStatusBar1;

TImage *Image1;

TsPanel *sPanel1;

TsColorSelect *sColorSelect1;

TsRadioButton *sRadioButton1;

TsRadioButton *sRadioButton2;

TsRadioButton *sRadioButton3;

TsBitBtn *sBitBtn1;

void __fastcall sBitBtn1Click(TObject *Sender);

void __fastcall check(TObject *Sender);

void __fastcall Image1MouseMove(TObject *Sender, TShiftState Shift,int X, int Y);

void __fastcall Image1MouseLeave(TObject *Sender);

void __fastcall sColorSelectChange1(TObject *Sender);

void __fastcall sBitBtn2Click(TObject *Sender);

void __fastcall Image1Click(TObject *Sender);

void __fastcall sRadioButton1Click(TObject *Sender);

void __fastcall sColorSelect1MouseEnter(TObject *Sender);

void __fastcall sColorSelect1MouseLeave(TObject *Sender);

private:

vector<point>Fpoints[6];

vector< vector<point>> Fpoints2;

public:

__fastcallTMainForm(TComponent* Owner);

// Вычисления

void recount();

double f1(double, double);

double f2(double, double);

double y(double, double);

double x(double, double);

// Работа с графиками

void paint();

voidfunctionPaint(TImage *, vector<functionOptions>, point, bool, bool);

voidaddFunction(vector<functionOptions>&, vector<point>, TColor, bool,

TPenStyle, AnsiString, int);

};

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

extern PACKAGE TMainForm *MainForm;

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

#endif

MainUnit.cpp

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

#include <vcl.h>

#include <math.h>

#pragma hdrstop

#include "MainUnit.h"

#include "EditUnit.h"

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

#pragma package(smart_init)

#pragma link "sPageControl"

#pragma link "sSkinManager"

#pragma link "sLabel"

#pragma link "sBitBtn"

#pragma link "sGroupBox"

#pragma link "sCheckBox"

#pragma link "sPanel"

#pragma link "sSkinProvider"

#pragma link "sUpDown"

#pragma link "sPageControl"

#pragma link "sColorSelect"

#pragma link "sSpeedButton"

#pragma link "acPNG"

#pragma link "sTrackBar"

#pragma link "sRadioButton"

#pragma link "sStatusBar"

#pragma resource "*.dfm"

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

TMainForm *MainForm;

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

__fastcallTMainForm::TMainForm(TComponent* Owner) : TForm(Owner)

{

recount();

}

/*--- Заданныефункцииправыхчастейсистемы --------------------------------

* x, y - концентрацииреагентов X и Y

*/

doubleTMainForm::f1(double x, double y)

{

returnOptions.b * x - x * x * y;

}

doubleTMainForm::f2(double x, double y)

{

returnOptions.a - (Options.b + 1) * x + x * x * y;

}

/*--- ПоискчисленныхрешенийсистемыметодомРунге-Кутты 3-его порядка -----

* y_prev, x_prev - предыдущиезначенияфункций

* Результат: Значениефункции в точке t + h

*/

doubleTMainForm::y(double x_prev, double y_prev)

{

double k1 = f1(x_prev, y_prev);

double k2 = f1(x_prev + Options.h * Options.b2 * k1, y_prev + Options.h * Options.b2 * k1);

double k3 = f1(x_prev + Options.h * (Options.b31 * k1 + Options.b32 * k2), y_prev + Options.h * (Options.b31 * k1 + Options.b32 * k2));

returny_prev + Options.h * (Options.c1 * k1 + Options.c2 * k2 + Options.c3 * k3);

}

doubleTMainForm::x(double x_prev, double y_prev)

{

double k1 = f2(x_prev, y_prev);

double k2 = f2(x_prev + Options.h * Options.b2 * k1, y_prev + Options.h * Options.b2 * k1);

double k3 = f2(x_prev + Options.h * (Options.b31 * k1 + Options.b32 * k2), y_prev + Options.h * (Options.b31 * k1 + Options.b32 * k2));

returnx_prev + Options.h * (Options.c1 * k1 + Options.c2 * k2 + Options.c3 * k3);

}

/*--- Поискминимума и максимума в вектореточекфункциинаплоскости ------

* P - векторточкек (x,y)

*/

doublemaxy(vector<point> P)

{

double max = 0;

if(P.size())

{

max = P.front().y;

for(int t = 1; t <P.size(); t++)

if(P[t].y > max) max = P[t].y;

}

return max;

}

doubleminy(vector<point> P)

{

double min = 0;

if(P.size())

{

min = P.front().y;

for(int t = 1; t <P.size(); t++)

if(P[t].y < min) min = P[t].y;

}

return min;

}

doublemaxx(vector<point> P)

{

double max = 0;

if(P.size())

{

max = P.front().x;

for(int t = 1; t <P.size(); t++)

if(P[t].x > max) max = P[t].x;

}

return max;

}

double minx(vector<point> P)

{

double min = 0;

if(P.size())

{

min = P.front().x;

for(int t = 1; t <P.size(); t++)

if(P[t].x < min) min = P[t].x;

}

return min;

}

//--- Расчёт задачи --------------------------------------------------------

voidTMainForm::recount()

{

double ta = Options.ta;

doubletb = Options.tb;

double h = Options.h;

double x0 = Options.x0;

double y0 = Options.y0;

// Коррекцияшага

h = (tb - ta) / (int((tb - ta) / h) + 1.);

// Начальныеусловия

Fpoints[0].clear();

Fpoints[1].clear();

Fpoints[2].clear();

point P1 = {ta, y0};

point P2 = {ta, x0};

point P3 = {y0, x0};

Fpoints[0].push_back(P1);

Fpoints[1].push_back(P2);

Fpoints[2].push_back(P3);

// Поискточексемействарешений

vector<point> T;

int j = 0, v = -1;

Fpoints2.clear();

for (int i = 0; j < 10; i++)

if(((y0 - 1) + i * 0.2) > 0)

{

if(v == -1)

v = i;

T.clear();

point P = {ta, (y0 - 1) + double(i) * 0.2};

if(fabs(P.y) < 0.00000001)

P.y = 0;

if(fabs(P.y - y0) < 0.00000001)

P.y = y0;

T.push_back(P);

if(Fpoints2.size() < 10)

Fpoints2.push_back(T);

j++;

}

j = 0;

for (int i = v; j < 10; i++)

if(((x0 - 1) + i * 0.2) > 0)

{

T.clear();

point P = {ta, (x0 - 1) + i * 0.2};

if(fabs(P.y) < 0.00000001)

P.y = 0;

if(fabs(P.y - x0) < 0.00000001)

P.y = x0;

T.push_back(P);

if(Fpoints2.size() < 20)

Fpoints2.push_back(T);

j++;

}

for (int i = 0; i < 10; i++)

{

T.clear();

point P = {Fpoints2[i].front().y, Fpoints2[i+10].front().y};

T.push_back(P);

Fpoints2.push_back(T);

}

for(int i = 0; i < 10; i++)

{

int j = 1;

for(double t = ta + h; t <= tb; t = ta + j * h)

{

point P1 = {t, y(Fpoints2[i + 10].back().y, Fpoints2[i].back().y)};

point P2 = {t, x(Fpoints2[i + 10].back().y, Fpoints2[i].back().y)};

point P3 = {P1.y, P2.y};

Fpoints2[i].push_back(P1);

Fpoints2[i + 10].push_back(P2);

Fpoints2[i + 20].push_back(P3);

j++;

}

}

paint();

MainForm->Refresh();

}

/*--- ПостроениеграфиковфункцийнакомпанентеTImage ---------------------

* Image - указательнаобъекттипаTImage

* Functions - векторструктур, определяющихточкиграфиковфункции

* изадающихпараметрыотрисовкиграфиков (цвет, стиль и т. п.)

* showGrid -определяет, рисоватьсеткуилинет

* zoom - координатацентраобластидляувеличения

* zoomed - определяет, увеличиватьобластьилинет

*/

voidTMainForm::functionPaint(TImage *Image, vector<functionOptions> Functions,

point zoom, bool zoomed = false, boolshowGrid = true)

{

int i, j, x, y, labelpos;

vector<point> F;

TColor color;

int width, height, gridNumX, gridNumY, gridStepX, gridStepY;

doubleminY, maxY, minX, maxX, kx, ky;

minX = minx(Functions.front().points);

maxX = maxx(Functions.front().points);

minY = miny(Functions.front().points);

maxY = maxy(Functions.front().points);

if(minY == maxY)

{

minY = minY - 2;

maxY = maxY + 5;

}

width = Image->Width;

height = Image->Height;

gridNumX = 10;

gridNumY = 16;

gridStepX = width / gridNumX;

gridStepY = height / gridNumY;

kx = double((maxX - minX) / (width - 2 * gridStepX));

ky = double((maxY - minY) / (height - 2 * gridStepY));

if(zoomed)

{

minX = (zoom.x - 2 * gridStepX) * kx;

maxX = zoom.x * kx;

minY = (height - zoom.y - 2.5 * gridStepY)* ky;

maxY = (height - zoom.y + 0.5 * gridStepY)* ky;

kx = double((maxX - minX) / (width - 2 * gridStepX));

ky = double((maxY - minY) / (height - 2 * gridStepY));

}

// Фон

Image->Picture->Bitmap->Height = Image->Height;

Image->Picture->Bitmap->Width = Image->Width;

Image->Canvas->Pen->Color = clBlack;

Image->Canvas->Brush->Color = clWhite;

Image->Canvas->Rectangle(0, 0, width, height);

// Сетка

if(showGrid)

{

Image->Canvas->Pen->Color = clInactiveCaption;

Image->Canvas->Pen->Style = psDot;

for(i = 1; i <gridNumX; i++)

{

Image->Canvas->MoveTo(i * gridStepX, 1);

Image->Canvas->LineTo(i * gridStepX, height - 1);

}

for(i = gridNumY - 1; i >= 1 ; i--)

{

Image->Canvas->MoveTo(1, i * gridStepY);

Image->Canvas->LineTo(width - 1, i * gridStepY);

}

}

Image->Canvas->Pen->Color = clBlack;

Image->Canvas->Pen->Style = psSolid;

for(i = 1; i <gridNumX; i++)

{

Image->Canvas->MoveTo(i * gridStepX, height - gridStepY + 3);

Image->Canvas->LineTo(i * gridStepX, height - gridStepY - 4);

}

for(i = gridNumY - 1; i >= 1 ; i--)

{

Image->Canvas->MoveTo(gridStepX - 3, i * gridStepY);

Image->Canvas->LineTo(gridStepX + 4, i * gridStepY);

}

Image->Canvas->MoveTo(gridStepX - 3, 23); Image->Canvas->LineTo(gridStepX, 10);

Image->Canvas->MoveTo(gridStepX + 3, 23); Image->Canvas->LineTo(gridStepX, 10);

Image->Canvas->LineTo(gridStepX, height - 11);

Image->Canvas->MoveTo(10, (gridNumY - 1) * gridStepY);

Image->Canvas->LineTo(width - 11, (gridNumY - 1) * gridStepY);

Image->Canvas->MoveTo(width - 11, (gridNumY - 1) * gridStepY); Image->Canvas->LineTo(width - 24, (gridNumY - 1) * gridStepY - 3);

Image->Canvas->MoveTo(width - 11, (gridNumY - 1) * gridStepY); Image->Canvas->LineTo(width - 24, (gridNumY - 1) * gridStepY + 3);

Image->Canvas->Pen->Width = 1;

// Масштаб

AnsiStringxLabel, yLabel;

Image->Canvas->Pen->Color = clBlack;

Image->Canvas->Brush->Style = bsClear;

Image->Canvas->Font->Color = clBlack;

for(i = (minY != minX) ? 1 : 3; i <gridNumX; i+= 2)

{

xLabel = FloatToStrF(minX + double((fabs(minX) + fabs(maxX)) * (i - 1) / (gridNumX - 2)), ffGeneral, 6, 0);

Image->Canvas->TextOutW(i * gridStepX + 1, height - gridStepY, xLabel);

}

for(i = gridNumY - 1; i >= 1; i-= 2)

{

yLabel = FloatToStrF(maxY - double((maxY - minY) * (i - 1) / (gridNumY - 2)), ffGeneral, 6, 0);

Image->Canvas->TextOutW(gridStepX - 6.5 * strlen(yLabel.c_str()), i * gridStepY + 1, yLabel);

}

// Графикифункций

for(i = 0; i <Functions.size(); i++)

{

if(Functions[i].enabled)

{

F = Functions[i].points;

color = Functions[i].color;

AnsiString label = Functions[i].label;

labelpos = Functions[i].labelpos;

Image->Canvas->Pen->Color = color;

Image->Canvas->Brush->Color = color;

Image->Canvas->Font->Color = color;

for(j = 0; j <F.size(); j++)

{

x = gridStepX + (F[j].x - minX) / kx;

y = height - gridStepY - (F[j].y - minY) / ky;

if (Functions[i].style == psDot)

Image->Canvas->Ellipse(x - 3, y - 3, x + 3, y + 3);

else

{

if (j == 0)

Image->Canvas->MoveTo(x, y);

else

Image->Canvas->LineTo(x, y);

}

if (label != ' ' &&labelpos<= j * 100 / F.size())

{

Image->Canvas->Brush->Style = bsClear;

Image->Canvas->TextOutW(x + 15, y + 5, label);

Image->Canvas->Brush->Color = color;

Image->Canvas->MoveTo(x, y);

label = ' ';

}

}

}

}

// Областьдляувеличения

if(zoom.x> 0 &&zoom.y> 0 && !zoomed)

{

Image->Canvas->Brush->Style = bsClear;

Image->Canvas->Pen->Color = clSkyBlue;

Image->Canvas->Pen->Width = 2;

Image->Canvas->Rectangle(zoom.x - gridStepX, zoom.y - 1.5 * gridStepY, zoom.x + gridStepX, zoom.y + 1.5 * gridStepY);

Image->Canvas->Pen->Width = 1;

Image->Cursor = crCross;

}

else

Image->Cursor = crDefault;

Image->Refresh();

}

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

voidTMainForm::addFunction(vector<functionOptions>&F, vector<point> P, TColor C, bool enabled = true, TPenStyle style = psDash, AnsiString label = ' ', int labelpos = 0)

{

functionOptions O;

O.points = P;

O.color = C;

O.label = label;

O.labelpos = labelpos;

O.enabled = enabled;

O.style = style;

F.push_back(O);

}

//--- Перерисовкаграфиковфункцийдлязаданныхточек -----------------------

voidTMainForm::paint()

{

vector<functionOptions> F;

if(sRadioButton1->Checked)

{

for (int i = 0; i < 10; i++)

addFunction(F, Fpoints2[i], (Fpoints2[i].front().y != Options.y0) ? sColorSelect1->ColorValue : clGreen, (Options.show_all || Fpoints2[i].front().y == Options.y0));

addFunction(F, Fpoints[0], clBlack, true, psDot);

}

if(sRadioButton2->Checked)

{

for (int i = 10; i < 20; i++)

addFunction(F, Fpoints2[i], (Fpoints2[i].front().y != Options.x0) ? sColorSelect1->ColorValue : clGreen, (Options.show_all || Fpoints2[i].front().y == Options.x0));

addFunction(F, Fpoints[1], clBlack, true, psDot);

}

if(sRadioButton3->Checked)

{

for (int i = 20; i < 30; i++)

addFunction(F, Fpoints2[i], (Fpoints2[i].front().y != Options.x0 && Fpoints2[i].front().x != Options.y0) ? sColorSelect1->ColorValue : clGreen, (Options.show_all || (Fpoints2[i].front().y == Options.x0 && Fpoints2[i].front().x == Options.y0)));

}

if(sRadioButton1->Checked || sRadioButton2->Checked || sRadioButton3->Checked)

functionPaint(Image1, F, zoom, zoomed, Options.show_grid);

}

//--- Открытьокнонастроекпрограммы ------------------------------------------------

void __fastcallTMainForm::sBitBtn1Click(TObject *Sender)

{

Application->CreateForm(__classid(TEditForm1), &EditForm1);

EditForm1->ShowModal();

}

//--- Выборграфиковдляотображения ----------------------------------------

void __fastcallTMainForm::check(TObject *Sender)

{

paint();

}

//--- Областьдляувеличенияграфика ----------------------------------------

void __fastcallTMainForm::Image1MouseMove(TObject *Sender, TShiftState Shift, int X,

int Y)

{

if(!zoomed)

{

zoom.x = X;

zoom.y = Y;

sStatusBar1->Panels->Items[0]->Text = " Щёлкнитемышью, чтобыувеличитьграфик";

paint();

}

else

sStatusBar1->Panels->Items[0]->Text = " Щёлкнитемышью, чтобыуменьшитьграфик";

}

void __fastcallTMainForm::Image1MouseLeave(TObject *Sender)

{

if(!zoomed)

{

zoom.x = zoom.y = 0;

paint();

}

sStatusBar1->Panels->Items[0]->Text = " Курсоваяработа \"Автоколебания в химическихреакциях\"";

}

void __fastcallTMainForm::Image1Click(TObject *Sender)

{

zoomed = !zoomed;

paint();

}

//--- Сменацветаграфиковфункций ------------------------------------------

void __fastcallTMainForm::sColorSelectChange1(TObject *Sender)

{

paint();

}

void __fastcallTMainForm::sColorSelect1MouseEnter(TObject *Sender)

{

sStatusBar1->Panels->Items[0]->Text = " Нажмите, чтобыизменитьцветграфиковфункций";

}

void __fastcallTMainForm::sColorSelect1MouseLeave(TObject *Sender)

{

sStatusBar1->Panels->Items[0]->Text = " Курсоваяработа \"Автоколебания в химическихреакциях\"";

}

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

EditUnit.h

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

#ifndefEditUnitH

#define EditUnitH

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

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include "sBitBtn.hpp"

#include "sEdit.hpp"

#include "sLabel.hpp"

#include <Buttons.hpp>

#include "sSkinProvider.hpp"

#include "sComboBoxes.hpp"

#include <ComCtrls.hpp>

#include "sColorSelect.hpp"

#include "sSpeedButton.hpp"

#include "sCheckBox.hpp"

#include "sTrackBar.hpp"

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

class TEditForm1 : public TForm

{

__published:// IDE-managed Components

TsLabel *sLabel1;

TsLabel *sLabel2;

TsLabel *sLabel3;

TsEdit *sEdit3;

TsEdit *sEdit4;

TsBitBtn *sBitBtn1;

TsBitBtn *sBitBtn2;

TsBitBtn *sBitBtn3;

TsSkinProvider *sSkinProvider1;

TsLabel *sLabel4;

TsEdit *sEdit5;

TsEdit *sEdit6;

TsEdit *sEdit7;

TsLabel *sLabel5;

TsLabel *sLabel6;

TsLabel *sLabel7;

TsLabel *sLabel8;

TsLabel *sLabel9;

TsLabel *sLabel10;

TsLabel *sLabel11;

TsLabel *sLabel12;

TsLabel *sLabel13;

TsLabel *sLabel14;

TsLabel *sLabel15;

TsLabel *sLabel16;

TsLabel *sLabel21;

TsLabel *sLabel17;

TsLabel *sLabel18;

TsLabel *sLabel19;

TsLabel *sLabel20;

TsCheckBox *sCheckBox1;

TsTrackBar *sTrackBar1;

TsTrackBar *sTrackBar2;

TsLabel *sLabel22;

TsLabel *sLabel23;

TsTrackBar *sTrackBar3;

TsTrackBar *sTrackBar4;

TsLabel *sLabel24;

TsLabel *sLabel25;

TsCheckBox *sCheckBox2;

void __fastcall sBitBtn1Click(TObject *Sender);

void __fastcall sBitBtn2Click(TObject *Sender);

void __fastcall sBitBtn3Click(TObject *Sender);

void __fastcall sTrackBar1Change(TObject *Sender);

void __fastcall sTrackBar2Change(TObject *Sender);

void __fastcall sCheckBox1Click(TObject *Sender);

void __fastcall sTrackBar3Change(TObject *Sender);

void __fastcall sTrackBar4Change(TObject *Sender);

void __fastcall sCheckBox2Click(TObject *Sender);

private:// User declarations

public:// User declarations

__fastcallTEditForm1(TComponent* Owner);

};

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

extern PACKAGE TEditForm1 *EditForm1;

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

#endif

EditUnit.cpp

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

#include <vcl.h>

#include <string>

#include <boost/regex.hpp>

#pragma hdrstop

#include "EditUnit.h"

#include "MainUnit.h"

#include "Common.h"

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

#pragma package(smart_init)

#pragma link "sBitBtn"

#pragma link "sEdit"

#pragma link "sLabel"

#pragma link "sSkinProvider"

#pragma link "sComboBoxes"

#pragma link "sColorSelect"

#pragma link "sSpeedButton"

#pragma link "sCheckBox"

#pragma link "sTrackBar"

#pragma resource "*.dfm"

TEditForm1 *EditForm1;

settingsOptions_old, Options_new;

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

__fastcall TEditForm1::TEditForm1(TComponent* Owner)

: TForm(Owner)

{

Options_old = Options;

// Концентрацииисходныхвеществ

sTrackBar1->Position = int(Options.a * 10.);

sTrackBar2->Position = int(Options.b * 10.);

sLabel22->Caption = FloatToStr(Options.a);

sLabel23->Caption = FloatToStr(Options.b);

// Отрезоквремени

sEdit3->Text = "[" + FloatToStr(Options.ta) + ";" + FloatToStr(Options.tb) + "]";

// Шаг

sEdit4->Text = Options.h;

// ПараметрыметодаРунге-Кутты

sEdit5->Text = Options.a1;

sEdit6->Text = Options.a2;

sEdit7->Text = Options.a3;

// Начальныеусловия

sTrackBar3->Position = int(Options.y0 * 10.);

sTrackBar4->Position = int(Options.x0 * 10.);

sLabel24->Caption = FloatToStr(Options.y0);

sLabel25->Caption = FloatToStr(Options.x0);

// Сетка

sCheckBox1->Checked = Options.show_grid;

// Семействорешений

sCheckBox2->Checked = Options.show_all;

}

//--- Настройкипоумолчанию ------------------------------------------------

void __fastcall TEditForm1::sBitBtn1Click(TObject *Sender)

{

// Концентрацииисходныхвеществ

sTrackBar1->Position = int(Options_default.a * 10.);

sTrackBar2->Position = int(Options_default.b * 10.);

sLabel22->Caption = FloatToStr(Options_default.a);

sLabel23->Caption = FloatToStr(Options_default.b);

// Отрезоквремени

sEdit3->Text = "[" + FloatToStr(Options_default.ta) + ";" +

FloatToStr(Options_default.tb) + "]";

// Шаг

sEdit4->Text = Options_default.h;

// ПараметрыметодаРунге-Кутты

sEdit5->Text = Options_default.a1;

sEdit6->Text = Options_default.a2;

sEdit7->Text = Options_default.a3;

// Начальныеусловия

sTrackBar3->Position = int(Options_default.y0 * 10.);

sTrackBar4->Position = int(Options_default.x0 * 10.);

sLabel24->Caption = FloatToStr(Options_default.y0);

sLabel25->Caption = FloatToStr(Options_default.x0);

// Сетка

sCheckBox1->Checked = Options_default.show_grid;

}

//--- Отменасделанныхизменений --------------------------------------------

void __fastcall TEditForm1::sBitBtn2Click(TObject *Sender)

{

Options = Options_old;

MainForm->recount();

Close();

}

//--- Сохранениенастроект --------------------------------------------------

void __fastcall TEditForm1::sBitBtn3Click(TObject *Sender)

{

AnsiString ta, tb, segment, h, a1, a2, a3;

segment = sEdit3->Text.Trim();

h = sEdit4->Text.Trim();

a1 = sEdit5->Text.Trim();

a2 = sEdit6->Text.Trim();

a3 = sEdit7->Text.Trim();

if (segment == "" || h == "" || a1 == "" || a2 == "" || a3 == "")

{

MessageDlg ("Заполненыневсеполянастроект!\nПожалуйста, введите

недостающиепараметры.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

std::string str(segment.c_str());

boost::smatch results;

boost::regexregexp("\\s*\\[\\s*([\-\\d\.\,]+)\\s*;\\s*([\-

\\d\.\,]+)\\s*\\]\\s*");

if(!regex_match(str, results, regexp))

{

MessageDlg ("Неверныйформатзаписиинтервала!\nПожалуйста, проверьте

введённыйинтервал.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

try

{

Options_new.ta = StrToFloat(results[1].str().c_str());

Options_new.tb = StrToFloat(results[2].str().c_str());

}

catch (...)

{

MessageDlg ("Неверныйформатзаписиинтервала!\nПожалуйста, проверьте

введённыйинтервал.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

if(Options_new.ta>= Options_new.tb)

{

MessageDlg ("Неверныйформатзаписиинтервала!\nПожалуйста, проверьте

введённыйинтервал.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

try

{

Options_new.h = StrToFloat(h);

}

catch (...)

{

MessageDlg ("Шагдолжныбытьвещественнымичислом!\nПожалуйста, проверьте

введённоезначениешага.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

if(Options_new.h<= 0)

{

MessageDlg ("Некорректноезначениешага!\nПожалуйста, проверьтевведённое

значениешага.", mtError, TMsgDlgButtons() <<mbOK, 0);

return;

}

try

{

Options_new.a1 = StrToFloat(a1);

Options_new.a2 = StrToFloat(a2);

Options_new.a3 = StrToFloat(a3);

}

catch (...)

{

MessageDlg ("Параметрыметодадолжныбытьвещественными

числами!\nПожалуйста, проверьтевведённыезначенияпараметров.", mtError,

TMsgDlgButtons() <<mbOK, 0);

return;

}

if(Options_new.a1 != 0 || Options_new.a2 <= Options_new.a1 || Options_new.a3 <=

Options_new.a2 || Options_new.a3 > 1)

{

MessageDlg ("Параметрыметодадолжныудовлетворятьусловию 0 = a1 < a2 <

a3 <= 1!\nПожалуйста, проверьтевведённыезначенияпараметров.", mtError,

TMsgDlgButtons() <<mbOK, 0);

return;

}

Options_new.show_grid = sCheckBox1->Checked;

Options_new.show_all = sCheckBox2->Checked;

Options = Options_new;

MainForm->recount();

Close();

}

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

void __fastcall TEditForm1::sTrackBar1Change(TObject *Sender)

{

Options_new.a = Options.a = double(sTrackBar1->Position) / 10.;

sTrackBar2->Max = int((pow(Options.a,2) + 1) * 10.);

sLabel22->Caption = Options.a;

MainForm->recount();

}

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

void __fastcall TEditForm1::sTrackBar2Change(TObject *Sender)

{

Options_new.b = Options.b = double(sTrackBar2->Position) / 10.;

sLabel23->Caption = Options.b;

MainForm->recount();

}

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

void __fastcall TEditForm1::sCheckBox1Click(TObject *Sender)

{

Options.show_grid = sCheckBox1->Checked;

MainForm->paint();

}

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

void __fastcall TEditForm1::sTrackBar3Change(TObject *Sender)

{

Options_new.y0 = Options.y0 = double(sTrackBar3->Position) / 10.;

sLabel24->Caption = Options.y0;

MainForm->recount();

}

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

void __fastcall TEditForm1::sTrackBar4Change(TObject *Sender)

{

Options_new.x0 = Options.x0 = double(sTrackBar4->Position) / 10.;

sLabel25->Caption = Options.x0;

MainForm->recount();

}

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

void __fastcall TEditForm1::sCheckBox2Click(TObject *Sender)

{

Options.show_all = sCheckBox2->Checked;

MainForm->paint();

}

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

Размещено на Allbest.ru