Моделирование канала записи-воспроизведения на ЭВМ

2. И.п. - о.с. 1 - шаг вправо, руки в стороны. 2 - повернуть кисти ладонями вверх. 3 - приставить левую ногу, руки вверх. 4 - руки дугами в стороны и вниз, свободным махом скрестить перед грудью. 5 - 8 - то же влево. Повторить 6-8 раз. Темп средний.

3. И.п. - стойка ноги врозь, руки в стороны. 1 - наклон вперед к правой ноге, хлопок в ладони. 2 - и.п. 3 - 4 - то же в другую сторону. Повторить 6 - 8 раз. Темп средний.

4. И.п. - стойка ноги врозь, левая впереди, руки в стороны или на поясе. 1 - 3 - три пружинистых полуприседа на левой ноге. 4 - переменить положение ног. 5 - 7 - то же, но правая нога впереди левой. Повторить 4 - 6 раз. Перейти на ходьбу 20 - 25 с. Темп средний.

5. И.п. - стойка ноги врозь пошире. 1 - с поворотом туловища влево наклон назад, руки назад. 2 - 3 - сохраняя положение туловища в повороте, пружинистый наклон вперед, руки вперед. 4 - и.п. 5 - 8 - то же, но поворот туловища вправо. Повторить по 4 - 6 раз в каждую сторону. Темп медленный.

6. И.п. - придерживаясь за опору, согнуть правую ногу, захватив рукой за голень. 1 - вставая на левый носок, мах правой ногой назад, правую руку в сторону - назад. 2 - и.п. 3 - 4 - то же, но согнуть левую ногу. Повторить 6 - 8 раз. Темп средний.

7. И.п. - о.с. 1 - руки назад в стороны, ладони наружу, голову наклонить назад. 2 - руки вниз, голову наклонить вперед. Повторить 6 - 8 раз. Темп медленный.

Физкультурная пауза 3

1. Ходьба не менее 20 - 30 с. Темп средний. 1. И.п. - о.с. Правой рукой дугой внутрь. 2 - то же левой и руки вверх, встать на носки. 3 - 4 - руки дугами в стороны. И.п. Повторить 4 - 6 раз. Темп медленный.

2. И.п. - о.с. 1 - с шагом вправо руки в стороны, ладони кверху. 2 - с поворотом туловища направо дугой кверху левую руку вправо с хлопком в ладони. 3 - выпрямиться. 4 - и.п. 5 - 8 - то же в другую сторону. Повторить 6 -8 раз. Темп средний.

3. И.п. - стойка ноги врозь. 1 - 3 - руки в стороны, наклон вперед и три размашистых поворота туловища в стороны. 4 - и.п. Повторить 6 - 8 раз. Темп средний.

4. И.п. - о.с. 1 - 2 - присед, колени врозь, руки вперед, 3 - 4 - встать, правую руку вверх, левую за голову. 5 - 8 - то же, но правую за голову. Повторить 6 -10 раз. Темп медленный.

5. И.п. - о.с. 1 - выпад влево, руки в стороны. 2 - 3 - руки вверх, два пружинистых наклона вправо. 4 - и.п. 5 - 8 - то же в другую сторону. Повторить 4 - 6 раз. Темп средний.

6. И.п. - правую руку на пояс, левой поддерживаться за опору. 1 - мах правой ногой вперед. 2 - мах правой ногой назад, захлестывая голень. То же проделать левой ногой. Повторить по 6 - 8 махов каждой ногой. Темп средний.

7. И.п. - о.с. 1 - 2 - правую ногу назад на носок, руки слегка назад с поворотом ладоней наружу, голову наклонить назад. 3 - 4 - ногу приставить, руки расслабленно опустить, голову наклонить вперед. 5 - 8 то же, отставляя другую ногу назад. Повторить 6 - 8 раз. Темп медленный.

Список использованной литературы

1. Трыков, Г.К. К столетию магнитной записи. Вестник связи. М., 1996, № 9, с. 47-48.

2. http://www.computer-museum.ru/technlgy/recorder.htm (25.04.2005)

3. Богородский, Ю.Л. Разрешающая способность систем магнитной записи/ Под ред. А.Ф. Богомолова. - М.: Энергия, 1980. - 112 с.

4. Вичес, А.И., Горон, А.И., Смирнов, В.А. моделирование канала магнитной записи на ЭВМ/ Под ред. А.И. Вичеса. - М.: Радио и связь, 1984. - 184 с.

5. Теоретические основы электрической передачи изображений, ч. 2/ Е. Л. Орловский, А.М. Халфин, Л.Д. Хазов и др. - М.: Советское радио, 1962. - 400 с.

6. Пеннин, П.И. К вопросу о пропускной способности канала связи с ограниченной пиковой мощностью сигналов. Тезисы доклада на Всесоюзной научной конференции МЭИ, сентябрь, 1977.

7. Богородский, Ю.Л. Разрешающая способность запоминающих устройств. - В кн.: Магнитные элементы автоматики и вычислительной техники. - М.: Наука, 1976, с. 234 - 235.

8. Рибель, И.Е. Разрешающая способность аппаратуры точной магнитной записи. - Измерительная техника, 1973, №7, с. 18-20.

9. Аксенов, В.А., Вичес А.И., Гитлиц М.В. Точная магнитная запись. - М.: Энергия, 1973. - 280 с.

10. Колосов, В. Современный любительский магнитофон. МРБ. -М.: Энергия, 1974. - 134 с.

11. Сухов, Н. Адаптивное динамическое подмагничивание// Радиоежегодник-91/ Сост. А.В. Гороховский, М.: Патриот, 1991.

12. Богородский, Ю.Л. Контактные потери в системах магнитной записи. - Техника кино и телевидения, 1973, № 4, с. 51-56.

100. Марчук, Г.И. Методы вычислительной математики. - М.: Наука, 1980. - 534 с.

101. ГОСТ 24863-81. Магнитофоны бытовые. Общие технические условия и методы измерения.

102. Организационно-экономические расчеты при создании и освоении новой техники: Учебное пособие./ Т.А. Шабалина, М.А. Азарская. - Йошкар-Ола: МарПИ, 1989. - 96 с.

Приложение

Листинг файла MainUnit.h

#ifndef MainUnitH

#define MainUnitH

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <fstream.h>

#include <iostream.h>

#include "te_controls.h"

#include "te_engine.h"

#include "te_managers.h"

#include "te_extra_Effect_Controls.h"

#include "GetVal.h"

#include "Definitions.h"

#include "RangeEdit.h"

#include "About.h"

#include <ExtCtrls.hpp>

#include <Graphics.hpp>

#include <math.h>

#include "Graph.h"

#include "ProgressBar.h"

#include "te_dialogs.h"

#include "Calculating.h"

extern const char *STR_ARRAY[25];

extern sRANGE_VAL g_rangeVal[23];

enum FILE_MANIP {INPUT_FILE, OUTPUT_FILE};

const int NUM_DATA = 20;

class TMainForm : public TForm

{

__published:// IDE-managed Components

TTeThemeEngine *ThEngine; TTeForm *ThForm;

TTeMenuBar *MenuBar;

TTeItem *mFile; TTeItem *mControl; TTeItem *mHelp;

TTeThemeList *ThList; TTeStatusBar *StatusBar; TTeGroupBox *gbControl;

TTeManager *ThManager; TTeGroupBox *gbHead;

TTeButton *bHD; TTeButton *bTD; TTeButton *bChP;

TTeGroupBox *gbHeadData; TTeGroupBox *gbCalculations;

TTeButton *bCalculate; TTeButton *bSaveRes;

TTeGroupBox *TeGroupBox1; TTeButton *bQuit;

TTeButton *bShowGraphics; TTeItem *smAbout; TTeItem *smQuit;

TTeLabel *TeLabel1; TTeComboBox *cbTypeOfHead;

TTeLabel *TeLabel2; TTeLabel *TeLabel8; TTeLabel *TeLabel3;

TTeLabel *TeLabel4; TTeLabel *TeLabel5; TTeLabel *TeLabel6;

TeLabel *TeLabel7; TTeEdit *eHDThicknessPlates;

TTeEdit *eHDKoercForce; TTeEdit *eHDInductance;

TTeEdit *eHDSpecElecResOfMater; TTeEdit *eHDInitMagnPermeab;

TTeEdit *eHDMaxMagnPermeab; TTeEdit *eHDWorkBacklashWide;

TTeGroupBox *gbTapeData; TTeLabel *TeLabel9;

TTeLabel *TeLabel10; TTeLabel *TeLabel11; TTeLabel *TeLabel12;

TTeLabel *TeLabel13; TTeLabel *TeLabel14; TTeLabel *TeLabel15;

TTeLabel *TeLabel16; TTeLabel *TeLabel17;

TTeComboBox *cbTypeOfTapeLayer; TTeEdit *eTDThicknessOfWorkLayer;

TTeEdit *eTDTapeKoercForce; TTeEdit *eTDResidualMagnet;

TTeEdit *eTDTapeInitMagnetPermeab; TTeEdit eTDTapeMaxMagnetPermeab;

TTeEdit *eTDSb; TTeEdit *eTDSm; TTeGroupBox *gbChParam;

TTeLabel *TeLabel18; TTeLabel *TeLabel19; TTeLabel *TeLabel20;

TTeLabel *TeLabel21; TTeLabel *TeLabel22; TTeEdit *eCPNonContactRec;

TTeEdit *eCPNonContactRep; TTeEdit *eCPVelCarrier; TTeEdit *eCPCurrent;

TTeEdit *eCPElecResAR; TTeItem *smAnother; TTeItem *smChangeRanges;

TTeItem *smHeadRange; TTeItem *smTapeRange; TTeItem *smChannelRange;

TTeItem *smBlWide; TTeItem *smNonContactRec;

TTeItem *smNonContactRep; TTeItem *smVelCar; TTeItem *smCurrent;

TTeItem *smElectrRes; TTeItem *smInductance; TTeItem *smKoercForce;

TTeItem *smInitMagnPermeab; TTeItem *smMaxMagnPermeab;

TTeItem *smSpecElRes; TTeItem *smThicknessPlates;

TTeItem *smTRMagnRes; TTeItem *smTRSb; TTeItem *smTRSm;

TTeItem *smTRInitMagnPerm; TTeItem *smTRMaxMagnPerm;

TTeItem *smTRThickWl; TTeItem *smTRKoercForce;

TTeItem *smSaveRange; TImage *FormImage; TPaintBox *PaintBox;

TTeItem *smSaveResult; TTeSaveDialog *sd; TTeItem *mTheme;

TTeItem *CustomItem1; TTeItem *CustomItem2; TTeItem *CustomItem3;

TTeItem *CustomItem4; TTeItem *CustomItem5; TTeItem *CustomItem6;

TTeItem *CustomItem7; TTeItem *CustomItem8; TTeItem *CustomItem9;

void __fastcall smQuitClick(TObject *Sender);

void __fastcall ThFormCreate(TObject *Sender);

void __fastcall bHDClick(TObject *Sender);

void __fastcall bTDClick(TObject *Sender);

void __fastcall bChPClick(TObject *Sender);

void __fastcall eOnEnter(TObject *Sender);

void __fastcall smChangeRangesClick(TObject *Sender);

void __fastcall smSaveRangeClick(TObject *Sender);

void __fastcall cbTypeOfHeadChange(TObject *Sender);

void __fastcall cbTypeOfTapeLayerChange(TObject *Sender);

void __fastcall FormClose(TObject *Sender, TCloseAction &Action);

void __fastcall smAboutClick(TObject *Sender);

void __fastcall bCalculateClick(TObject *Sender);

void __fastcall bShowGraphicsClick(TObject *Sender);

void __fastcall bSaveResClick(TObject *Sender);

void __fastcall CustomItem1Click(TObject *Sender);

void __fastcall CustomItem2Click(TObject *Sender);

void __fastcall CustomItem3Click(TObject *Sender);

void __fastcall bQuitClick(TObject *Sender);

void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);

void __fastcall CustomItem4Click(TObject *Sender);

void __fastcall CustomItem5Click(TObject *Sender);

void __fastcall CustomItem6Click(TObject *Sender);

void __fastcall CustomItem7Click(TObject *Sender);

void __fastcall CustomItem8Click(TObject *Sender);

void __fastcall CustomItem9Click(TObject *Sender);

void __fastcall FormShow(TObject *Sender);

private:// User declarations

int curVal;

int curMenuItem;

int countTD, countHD;

sRANGE_VAL rangeVal[23];

sHD_RANGE rhd; sTD_RANGE rtd; sCP_RANGE rcp;

void __fastcall InitRangeValues(sHD_RANGE rhd, sTD_RANGE rtd, sCP_RANGE rcp);

void __fastcall LoadRangeValues(sHD_RANGE &rhd, sTD_RANGE &rtd, sCP_RANGE &rcp);

void __fastcall OnHint(TObject *Sender); void __fastcall PrepearingData();

void __fastcall SaveLastProjData(); void __fastcall LoadLastProjData();

void __fastcall RefreshData(); void __fastcall RefreshHeadData();

void __fastcall RefreshTapeData(); void __fastcall RefreshChannelData();

void __fastcall LoadHD(); void __fastcall LoadTD();

void __fastcall ProccesHDChange(); void __fastcall ProccesTDChange();

public:// User declarations

bool isMain;

sHeadData hd, masHD[NUM_DATA];

sTapeData td, masTD[NUM_DATA];

sChParam cp; cAccounts calc;

String dataPath; String appPath; String picPath;

double __fastcall GetMinRangeVal(int curVal) {return (rangeVal[curVal].min);};

double __fastcall GetMaxRangeVal(int curVal)

{return (rangeVal[curVal].max);};

void __fastcall LetVal(double val);

void __fastcall LetRange(sRANGE_VAL range);

int __fastcall GetCurVal() {return (curVal);};

int __fastcall GetCurMenuItem() {return (curMenuItem);};

void __fastcall GetGraphData(int type, sGraphData &graph_data, sRect rect,

sGridData &grid_data, bool norm = false);

__fastcall TMainForm(TComponent* Owner);

};

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

extern PACKAGE TMainForm *MainForm;

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

#endif

Листинг файла MainUnit.cpp

#include <vcl.h>

#pragma hdrstop

#include "MainUnit.h"

#pragma package(smart_init)

#pragma link "te_controls"

#pragma link "te_engine"

#pragma link "te_managers"

#pragma link "te_extra_Effect_Controls"

#pragma link "te_dialogs"

#pragma resource "*.dfm"

TMainForm *MainForm;

const char *FILE_RANGE_NAME = "limparam.dat";

const char *FILE_HD_USER_NAME = "UserHD.dat";

const char *FILE_HD_NAME = "HD.dat";

const char *FILE_TD_NAME = "TD.dat";

const char *FILE_TD_USER_NAME = "UserTD.dat";

const char *FILE_LAST_PRJ_DATA_NAME = "lpd.dat";

__fastcall TMainForm::TMainForm(TComponent* Owner) : TForm(Owner){ }

void __fastcall TMainForm::ThFormCreate(TObject *Sender)

{

Application->OnHint = &OnHint; Application->HintColor = clAqua;

Application->HintHidePause = 3000; Application->HintPause = 300;

appPath = GetCurrentDir(); dataPath = appPath + "\\Data"; picPath = appPath + "\\Pict";

bSaveRes->Enabled = false; bShowGraphics->Enabled = false;

gbHeadData->Visible = false; gbTapeData->Visible = false;

gbChParam->Visible = false; smSaveRange->Enabled = false;

InitRangeValues(rhd, rtd, rcp); LoadHD(); LoadTD();

LoadLastProjData(); isMain = true;

}

void __fastcall TMainForm::InitRangeValues(sHD_RANGE rhd, sTD_RANGE rtd, sCP_RANGE rcp)

{

SetCurrentDir(dataPath);

LoadRangeValues(rhd, rtd, rcp);

rangeVal[HD_BL_WIDE] = rhd.workBacklashWide;

rangeVal[HD_INDUCT] = rhd.inductance;

rangeVal[HD_INIT_MAGN_PERM] = rhd.initMagnPermeab;

rangeVal[HD_KOERC_FORCE] = rhd.koercForce;

rangeVal[HD_MAX_MAGN_PERM] = rhd.maxMagnPermeab;

rangeVal[HD_THICKNESS_PLATES_OF_CORE] = rhd.thicknessPlatesOfCore;

rangeVal[HD_SPEC_ELECT_RES] = rhd.specElecResOfMater;

rangeVal[TD_THICKNESS_OF_WORK_LAYER] = rtd.thicknessOfWorkLayer;

rangeVal[TD_MAX_MAGN_PERMEAB_OF_CARRIER] = rtd.maxMagnPermeabOfCarrier;

rangeVal[TD_INIT_MAGN_PERMEAB_OF_CARRIER] = rtd.initMagnPermeabOfCarrier;

rangeVal[TD_RESIDUAL_MAGN] = rtd.residualMagn;

rangeVal[TD_KOERC_FORCE] = rtd.koercForce;

rangeVal[TD_SB] = rtd.sb; rangeVal[TD_SM] = rtd.sm;

rangeVal[CP_NON_CONTACT_REC] = rcp.nonContactRec;

rangeVal[CP_NON_CONTACT_REP] = rcp.nonContactRep;

rangeVal[CP_AMP_RESIST] = rcp.resistOfRepAmp;

rangeVal[CP_CURRENT] = rcp.current;

rangeVal[CP_CARRIER_SPEED] = rcp.speedOfMoveCarrier;

}

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

sCP_RANGE &rcp)

{

ifstream f;

f.open(FILE_RANGE_NAME, ios::binary);

if (!f)

{

String str = "Неудача при открытии файла " + (String)FILE_RANGE_NAME + "!";

ShowMessage(str);

return;

}

f.read((char*)&rhd, sizeof(sHD_RANGE));

f.read((char*)&rtd, sizeof(sTD_RANGE));

f.read((char*)&rcp, sizeof(sCP_RANGE));

f.close();

}

void __fastcall TMainForm::LoadHD()

{

ifstream f; f.open(FILE_HD_NAME, ios::binary);

if (!f)

{

String str = "Ошибка при открытии файла " + (String)FILE_HD_NAME +" !";

ShowMessage(str); return;

}

countHD = 0;

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

{

if (f.eof()) break; countHD++; f.read((char*)&masHD[i], sizeof(sHeadData));

}

f.close(); countHD -= 1;

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

cbTypeOfHead->Items->Add(masHD[i].name);

return;

}

void __fastcall TMainForm::LoadTD()

{

ifstream f; f.open(FILE_TD_NAME, ios::binary);

if (!f)

{

String str = "Ошибка при открытии файла " + (String)FILE_TD_NAME +" !";

ShowMessage(str); return;

}

countTD = 0;

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

{

if (f.eof()) break; countTD++; f.read((char*)&masTD[i], sizeof(sTapeData));

}

f.close(); countTD -= 1;

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

cbTypeOfTapeLayer->Items->Add(masTD[i].name);

return;

}

void __fastcall TMainForm::LoadLastProjData()

{

ifstream f;

f.open(FILE_LAST_PRJ_DATA_NAME, ios::binary);

if (!f) return;

char str[50]; f.read(str, sizeof(str)); cbTypeOfHead->Text = (WideString)str;

f.read(str, sizeof(str)); cbTypeOfTapeLayer->Text = (WideString)str;

f.read((char*)&cp, sizeof(sChParam)); int skin = 0;

f.read((char*)&skin, sizeof(int)); f.close();

ThEngine->ThemeIndex = skin;

if (skin == 1) ThEngine->DeltaBrightness = 80;

if (skin == 20) ThEngine->ThemeBuilding = "Flat";

if (skin == 21) ThEngine->ThemeBuilding = "OfficeXP";

ProccesHDChange();

ProccesTDChange();

RefreshChannelData();

}

void __fastcall TMainForm::SaveLastProjData()

{

ofstream f; f.open(FILE_LAST_PRJ_DATA_NAME, ios::binary);

if (!f) return;

char str[50];

StrPCopy(str, (String)cbTypeOfHead->Text); f.write(str, sizeof(str));

StrPCopy(str, (String)cbTypeOfTapeLayer->Text); f.write(str, sizeof(str));

f.write((char*)&cp, sizeof(sChParam)); int skin = ThEngine->ThemeIndex;

if (ThEngine->ThemeBuilding != "No theme")

{

if (ThEngine->ThemeBuilding == "Flat") skin = 20;

if (ThEngine->ThemeBuilding == "OfficeXP") skin = 21;

}

f.write((char*)&skin, sizeof(int)); f.close();

}

void __fastcall TMainForm::OnHint(TObject *Sender)

{

StatusBar->Panels->Items[0]->Text = Application->Hint;

}

void __fastcall TMainForm::smQuitClick(TObject *Sender)

{

PostQuitMessage(0);

}

void __fastcall TMainForm::bHDClick(TObject *Sender)

{

gbTapeData->Visible = false; gbChParam->Visible = false;

gbHeadData->Visible = gbHeadData->Visible ? false : true;

}

void __fastcall TMainForm::bTDClick(TObject *Sender)

{

gbHeadData->Visible = false; gbChParam->Visible = false;

gbTapeData->Visible = gbTapeData->Visible ? false : true;

}

void __fastcall TMainForm::bChPClick(TObject *Sender)

{

gbHeadData->Visible = false; gbTapeData->Visible = false;

gbChParam->Visible = gbChParam->Visible ? false : true;

}

void __fastcall TMainForm::LetVal(double val)

{

switch (curVal)

{

case HD_BL_WIDE : hd.workBacklashWidth = val; break;

case HD_INDUCT : hd.inductance = val; break;

case HD_INIT_MAGN_PERM : hd.initMagnPermeab = val; break;

case HD_KOERC_FORCE : hd.koercForce = val; break;

case HD_MAGN_RES_OF_BL : hd.magnResOfBacklash = val; break;

case HD_MAGN_RES_OF_CORE : hd.magnResOfCore = val; break;

case HD_MAX_MAGN_PERM : hd.maxMagnPermeab = val; break;

case HD_RAD_OF_POLE_TIPS : hd.radiusOfPoleTips = val; break;

case HD_SPEC_ELECT_RES : hd.specElecResOfMater = val; break;

case HD_THICKNESS_PLATES_OF_CORE : hd.thicknessPlatesOfCore = val; break;

case HD_WIDTH_POLE_TIPS : hd.widthOfPoleTips = val; break;

case TD_INIT_MAGN_PERMEAB_OF_CARRIER : td.initMagnPermeabOfCarrier = val; break;

case TD_KOERC_FORCE : td.koercForce = val; break;

case TD_MAX_MAGN_PERMEAB_OF_CARRIER : td.maxMagnPermeabOfCarrier = val; break;

case TD_RESIDUAL_MAGN : td.residualMagn = val; break;

case TD_THICKNESS_OF_WORK_LAYER : td.thicknessOfWorkLayer = val; break;

case TD_SB : td.sb = val; break;

case TD_SM : td.sm = val; break;

case CP_AMP_RESIST : cp.resistOfRepAmp = val; break;

case CP_CURRENT : cp.current = val; break;

case CP_CARRIER_SPEED : cp.speedOfMoveCarrier = val; break;

case CP_NON_CONTACT_REC : cp.nonContactRec = val; break;

case CP_NON_CONTACT_REP : cp.nonContactRep = val; break;

}

}

void __fastcall TMainForm::LetRange(sRANGE_VAL range)

{

switch (curMenuItem)

{

case HD_BL_WIDE : rhd.workBacklashWide = range; break;

case HD_INDUCT : rhd.inductance = range; break;

case HD_INIT_MAGN_PERM : rhd.initMagnPermeab = range; break;

case HD_KOERC_FORCE : rhd.koercForce = range; break;

case HD_MAX_MAGN_PERM : rhd.maxMagnPermeab = range; break;

case HD_SPEC_ELECT_RES : rhd.specElecResOfMater = range; break;

case HD_THICKNESS_PLATES_OF_CORE : rhd.thicknessPlatesOfCore = range; break;

case TD_INIT_MAGN_PERMEAB_OF_CARRIER : rtd.initMagnPermeabOfCarrier = range; break;

case TD_KOERC_FORCE : rtd.koercForce = range; break;

case TD_MAX_MAGN_PERMEAB_OF_CARRIER : rtd.maxMagnPermeabOfCarrier = range; break;

case TD_RESIDUAL_MAGN : rtd.residualMagn = range; break;

case TD_THICKNESS_OF_WORK_LAYER : rtd.thicknessOfWorkLayer = range; break;

case TD_SB : rtd.sb = range; break;

case TD_SM : rtd.sm = range; break;

case CP_AMP_RESIST : rcp.resistOfRepAmp = range; break;

case CP_CURRENT : rcp.current = range; break;

case CP_CARRIER_SPEED : rcp.speedOfMoveCarrier = range; break;

case CP_NON_CONTACT_REC : rcp.nonContactRec = range; break;

case CP_NON_CONTACT_REP : rcp.nonContactRep = range; break;

}

ShowMessage("Пределы допустимых значений параметра успешно изменены !");

smSaveRange->Enabled = true;

}

void __fastcall TMainForm::eOnEnter(TObject *Sender)

{

if (Sender == eCPNonContactRec) curVal = CP_NON_CONTACT_REC;

if (Sender == eCPNonContactRep) curVal = CP_NON_CONTACT_REP;

if (Sender == eCPCurrent) curVal = CP_CURRENT;

if (Sender == eCPElecResAR) curVal = CP_AMP_RESIST;

if (Sender == eCPVelCarrier) curVal = CP_CARRIER_SPEED;

if (Sender == eHDInductance) curVal = HD_INDUCT;

if (Sender == eHDInitMagnPermeab) curVal = HD_INIT_MAGN_PERM;

if (Sender == eHDKoercForce) curVal = HD_KOERC_FORCE;

if (Sender == eHDMaxMagnPermeab) curVal = HD_MAX_MAGN_PERM;

if (Sender == eHDSpecElecResOfMater) curVal = HD_SPEC_ELECT_RES;

if (Sender == eHDThicknessPlates) curVal = HD_THICKNESS_PLATES_OF_CORE;

if (Sender == eHDWorkBacklashWide) curVal = HD_BL_WIDE;

if (Sender == eTDResidualMagnet) curVal = TD_RESIDUAL_MAGN;

if (Sender == eTDSb) curVal = TD_SB; if (Sender == eTDSm) curVal = TD_SM;

if (Sender == eTDTapeInitMagnetPermeab) curVal = TD_INIT_MAGN_PERMEAB_OF_CARRIER;

if (Sender == eTDTapeKoercForce) curVal = TD_KOERC_FORCE;

if (Sender == eTDTapeMaxMagnetPermeab) curVal = TD_MAX_MAGN_PERMEAB_OF_CARRIER;

if (Sender == eTDThicknessOfWorkLayer) curVal = TD_THICKNESS_OF_WORK_LAYER;

Application->CreateForm(__classid(TFormGetVal), &FormGetVal);

FormGetVal->ShowModal(); FormGetVal->Hide();

FormGetVal->Release(); RefreshData();

}

void __fastcall TMainForm::RefreshHeadData()

{

eHDInductance->Text = FloatToStr(hd.inductance);

eHDInitMagnPermeab->Text = FloatToStr(hd.initMagnPermeab);

eHDKoercForce->Text = FloatToStr(hd.koercForce);

eHDMaxMagnPermeab->Text = FloatToStr(hd.maxMagnPermeab);

eHDSpecElecResOfMater->Text = FloatToStr(hd.specElecResOfMater);

eHDThicknessPlates->Text = FloatToStr(hd.thicknessPlatesOfCore);

eHDWorkBacklashWide->Text = FloatToStr(hd.workBacklashWidth);

}

void __fastcall TMainForm::RefreshTapeData()

{

eTDResidualMagnet->Text = FloatToStr(td.residualMagn);

eTDSb->Text = FloatToStr(td.sb); eTDSm->Text = FloatToStr(td.sm);

eTDTapeInitMagnetPermeab->Text = FloatToStr(td.initMagnPermeabOfCarrier);

eTDTapeKoercForce->Text = FloatToStr(td.koercForce);

eTDTapeMaxMagnetPermeab->Text = FloatToStr(td.maxMagnPermeabOfCarrier);

eTDThicknessOfWorkLayer->Text = FloatToStr(td.thicknessOfWorkLayer);

}

void __fastcall TMainForm::RefreshChannelData()

{

eCPCurrent->Text = FloatToStr(cp.current);

eCPElecResAR->Text = FloatToStr(cp.resistOfRepAmp);

eCPNonContactRec->Text = FloatToStr(cp.nonContactRec);

eCPNonContactRep->Text = FloatToStr(cp.nonContactRep);

eCPVelCarrier->Text = FloatToStr(cp.speedOfMoveCarrier);

}

void __fastcall TMainForm::RefreshData()

{

RefreshHeadData(); RefreshTapeData(); RefreshChannelData();

}

void __fastcall TMainForm::smChangeRangesClick(TObject *Sender)

{

if (Sender == smCurrent) curMenuItem = CP_CURRENT;

if (Sender == smNonContactRec) curMenuItem = CP_NON_CONTACT_REC;

if (Sender == smNonContactRep) curMenuItem = CP_NON_CONTACT_REP;

if (Sender == smElectrRes) curMenuItem = CP_AMP_RESIST;

if (Sender == smVelCar) curMenuItem = CP_CARRIER_SPEED;

if (Sender == smBlWide) curMenuItem = HD_BL_WIDE;

if (Sender == smInductance) curMenuItem = HD_INDUCT;

if (Sender == smInitMagnPermeab) curMenuItem = HD_INIT_MAGN_PERM;

if (Sender == smKoercForce) curMenuItem = HD_KOERC_FORCE;

if (Sender == smMaxMagnPermeab) curMenuItem = HD_MAX_MAGN_PERM;

if (Sender == smSpecElRes) curMenuItem = HD_SPEC_ELECT_RES;

if (Sender == smThicknessPlates) curMenuItem = HD_THICKNESS_PLATES_OF_CORE;

if (Sender == smTRInitMagnPerm) curMenuItem = TD_INIT_MAGN_PERMEAB_OF_CARRIER;

if (Sender == smTRKoercForce) curMenuItem = TD_KOERC_FORCE;

if (Sender == smTRMagnRes) curMenuItem = TD_RESIDUAL_MAGN;

if (Sender == smTRMaxMagnPerm) curMenuItem = TD_MAX_MAGN_PERMEAB_OF_CARRIER;

if (Sender == smTRSb) curMenuItem = TD_SB;

if (Sender == smTRSm) curMenuItem = TD_SM;

if (Sender == smTRThickWl) curMenuItem = TD_THICKNESS_OF_WORK_LAYER;

Application->CreateForm(__classid(TFormRangeEdit), &FormRangeEdit);

FormRangeEdit->ShowModal();

FormRangeEdit->Hide();

FormRangeEdit->Release();

}

void __fastcall TMainForm::smSaveRangeClick(TObject *Sender)

{

ofstream f; f.open(FILE_RANGE_NAME, ios::binary);

if (!f)

{

ShowMessage("Неудача при сохранении в файл !"); return;

}

f.write((char*)&rhd, sizeof(sHD_RANGE)); f.write((char*)&rtd, sizeof(sTD_RANGE));

f.write((char*)&rcp, sizeof(sCP_RANGE)); f.close();

ShowMessage("Данные успешно сохранены в файл !");

smSaveRange->Enabled = false;

}

void __fastcall TMainForm::ProccesHDChange()

{

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

if (cbTypeOfHead->Text == (String)masHD[i].name)

{

hd = masHD[i]; break;

}

RefreshHeadData();

}

void __fastcall TMainForm::cbTypeOfHeadChange(TObject *Sender)

{

ProccesHDChange();

}

void __fastcall TMainForm::ProccesTDChange()

{

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

{

if (cbTypeOfTapeLayer->Text == (String)masTD[i].name)

{

td = masTD[i];

break;

}

}

RefreshTapeData();

}

void __fastcall TMainForm::cbTypeOfTapeLayerChange(TObject *Sender)

{

ProccesTDChange();

}

void __fastcall TMainForm::FormClose(TObject *Sender, TCloseAction &Action)

{

SaveLastProjData();

PostQuitMessage(0);

}

void __fastcall TMainForm::smAboutClick(TObject *Sender)

{

FormAbout->ShowModal();

FormAbout->Hide();

}

void __fastcall TMainForm::PrepearingData()

{

cp.alpha = td.koercForce / (sqrt(2.0f) * td.sb); hd.widthOfPoleTips = hd.workBacklashWidth;

hd.radiusOfPoleTips = 0.5f; hd.magnResOfCore = 20.0f; hd.magnResOfBacklash = 50.0f;

calc.GetData(hd); calc.GetData(td); calc.GetData(cp);

}

void __fastcall TMainForm::bCalculateClick(TObject *Sender)

{

PrepearingData();

if (calc.Calculate())

{

bShowGraphics->Enabled = true; bSaveRes->Enabled = true;

}

}

void __fastcall TMainForm::CustomItem1Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeBuilding = "Flat";

}

void __fastcall TMainForm::CustomItem2Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeBuilding = "OfficeXP";

}

void __fastcall TMainForm::CustomItem3Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeIndex = 0;

}

void __fastcall TMainForm::CustomItem4Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 80; ThEngine->ThemeIndex = 1;

}

void __fastcall TMainForm::CustomItem5Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeIndex = 2;

}

void __fastcall TMainForm::CustomItem6Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0;

ThEngine->ThemeIndex = 3;

}

void __fastcall TMainForm::CustomItem7Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeIndex = 4;

}

void __fastcall TMainForm::CustomItem8Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0;

ThEngine->ThemeIndex = 5;

}

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

void __fastcall TMainForm::CustomItem9Click(TObject *Sender)

{

ThEngine->DeltaBrightness = 0; ThEngine->ThemeIndex = 6;

}

void __fastcall TMainForm::bQuitClick(TObject *Sender)

{

PostQuitMessage(0);

}

void __fastcall TMainForm::GetGraphData(int type, sGraphData &graph_data,

sRect rect, sGridData &grid_data, bool norm)

{

calc.CalculateGraphPoints(type, graph_data, rect, grid_data, norm);

}

Листинг файла Graph.h

#ifndef GraphH

#define GraphH

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include "te_controls.h"

#include <ExtCtrls.hpp>

#include "te_extended.h"

#include "MainUnit.h"

#include "definitions.h"

#include "te_engine.h"

#include "te_managers.h"

#include <Dialogs.hpp>

#include <ExtDlgs.hpp>

#include "te_dialogs.h"

#include "Calculating.h"

#include "PERFGRAP.h"

#include "stdlib.h"

class TFormGraph : public TForm

{

__published:// IDE-managed Components

TTeGroupBox *gbGraphControl; TTeForm *TeFormGraph; TTeButton *bDynRange;

TTeButton *bPWC; TTeButton *bPuls; TTePanel *pGraph;

TTeStatusBar *TeStatusBar1; TPaintBox *pb; TTeButton *bAWCFlow;

TTeButton *bFactOfHarm; TTeGroupBox *TeGroupBox1; TTeButton *bSavePic;

TTeGroupBox *gbQuit; TTeButton *TeButton1; TTeThemeEngine *TeThemeEngine1;

TTePanel *TePanel1; TTeButton *bAWCEdf; TTeButton *bMoreDynRange;

TTeButton *bMoreAWCEdf; TTeButton *bMoreImp; TTeButton *bMorePWC;

TTeButton *bMoreFactOfHarm; TTeButton *bMoreAWCFlow; TTeCheckBox *CheckBox;

TTeSavePictureDialog *spd; TTeGroupBox *gbTapeCharacter;

void __fastcall FormCreate(TObject *Sender);

void __fastcall bAWCOnFlowClick(TObject *Sender);

void __fastcall FormPaint(TObject *Sender); void __fastcall bPWCClick(TObject *Sender);

void __fastcall bAWCFlowClick(TObject *Sender);

void __fastcall bFactOfHarmClick(TObject *Sender);

void __fastcall bPulsClick(TObject *Sender);

void __fastcall bSavePicClick(TObject *Sender);

void __fastcall bAWCEdfClick(TObject *Sender);

void __fastcall bMoreClick(TObject *Sender);

void __fastcall CheckBoxClick(TObject *Sender);

void __fastcall bDynRangeClick(TObject *Sender);

private:

sHeadData hd; sTapeData td; sChParam cp; cAccounts calc;

bool graph, grid; sRect paint_rect;

double mas1[LEN], mas2[LEN], mas3[LEN];

int curGraph; eRET_VAL cur_grid; int choose;

double vals[3]; bool isDrawMas; bool reDraw;

TColor graph_color; int pen_width; sGraphData graph_data; sGridData grid_data;

void __fastcall DrawPozGrid(); void __fastcall DrawNegGrid();

void __fastcall DrawPNGrid(); void __fastcall ClearCanvas();

void __fastcall DrawGraphics(); void __fastcall DrawGrid();

public:

void __fastcall DrawGraphic();//sGraphData gd);

void __fastcall PutChoose(int ch) { choose = ch; };

void __fastcall PutData(double val1, double val2, double val3);

__fastcall TFormGraph(TComponent* Owner);

};

extern PACKAGE TFormGraph *FormGraph;

#endif

Листинг файла Graph.cpp

#include <vcl.h>

#pragma hdrstop

#include "Graph.h"

#pragma package(smart_init)

#pragma link "te_controls"

#pragma link "te_extended"

#pragma link "te_engine"

#pragma link "te_managers"

#pragma link "PERFGRAP"

#pragma resource "*.dfm"

TFormGraph *FormGraph;

__fastcall TFormGraph::TFormGraph(TComponent* Owner) : TForm(Owner){ }

void __fastcall TFormGraph::FormCreate(TObject *Sender)

{

Left = 0; Top = -50;

Height = GetSystemMetrics(SM_CYSCREEN);

Width = GetSystemMetrics(SM_CXSCREEN);

gbQuit->Top = Height - 100; pGraph->Height = Height - 62;

pGraph->Width = Width - 205; pb->Height = Height - 62; pb->Width = Width - 205;

graph = grid = false; paint_rect.x1 = 40; paint_rect.y1 = 30;

paint_rect.x2 = pb->Width - 15; paint_rect.y2 = pb->Height - 30;

grid = true; isDrawMas = false; reDraw = false; graph_color = clBlack; pen_width = 1;

}

void __fastcall TFormGraph::ClearCanvas()

{

pb->Canvas->Pen->Color = clBlack; pb->Canvas->FillRect(pb->Canvas->ClipRect);

}

void __fastcall TFormGraph::DrawGraphics()

{

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

pb->Canvas->Pen->Color = clHotLight;//0x00074B9A;// clRed;

if (isDrawMas)

{

pb->Canvas->Pen->Color = clBlack; pb->Canvas->Polyline(p1, LEN-1);

pb->Canvas->Pen->Color = clRed; pb->Canvas->Polyline(p2, LEN-1);

pb->Canvas->Pen->Color = clGreen; pb->Canvas->Polyline(p3, LEN-1);

}

else

pb->Canvas->Polyline(p, LEN-1); }

void __fastcall TFormGraph::FormPaint(TObject *Sender)

{

if (grid) DrawGrid();

if (graph) DrawGraphic();

}

void __fastcall TFormGraph::bPWCClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_PWC_CHANNEL, graph_data, paint_rect, grid_data);

Repaint();

}

void __fastcall TFormGraph::bAWCFlowClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_AWC_CHANNEL_ON_FLOW, graph_data, paint_rect, grid_data, true);

Repaint();

}

void __fastcall TFormGraph::bFactOfHarmClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_FACT_OF_HARM, graph_data, paint_rect, grid_data);

Repaint();

}

void __fastcall TFormGraph::bPulsClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_PULS_CHARACT, graph_data, paint_rect, grid_data);

Repaint();

}

void __fastcall TFormGraph::bAWCEdfClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_AWC_CHANNEL_ON_EDF, graph_data, paint_rect, grid_data, true);

Repaint();

}

void __fastcall TFormGraph::bSavePicClick(TObject *Sender)

{

spd->InitialDir = GetCurrentDir();

if (spd->Execute())

{

Graphics::TBitmap *bitmap = new Graphics::TBitmap;

bitmap->Height = pb->Height; bitmap->Width = pb->Width; TRect dest;

bitmap->Canvas->CopyRect(bitmap->Canvas->ClipRect, pb->Canvas, pb->Canvas->ClipRect);

String name = spd->FileName; String dir;

for(int i = name.Length(); i >= 1; i--)

if (name[i] == '\\')

{

dir = name.SubString(1, i); name = name.SubString(i + 1, name.Length() - i);

break;

}

if (name != "")

{

String curdir = GetCurrentDir(); SetCurrentDir(dir); bitmap->SaveToFile(name);

SetCurrentDir(curdir); ShowMessage("Успешно сохранено !");

}

}

}

void __fastcall TFormGraph::PutData(double val1, double val2, double val3)

{

vals[0] = val1; vals[1] = val2; vals[2] = val3;

}

void __fastcall TFormGraph::CheckBoxClick(TObject *Sender)

{

if (CheckBox->Checked) reDraw = true; else reDraw = false;

}

void __fastcall TFormGraph::DrawGrid()

{

if (!reDraw)

{

pb->Canvas->Brush->Color = clLtGray; pb->Canvas->FillRect(pb->Canvas->ClipRect);

}

pb->Canvas->Pen->Width = 1; int scal = (paint_rect.x2 - paint_rect.x1) / LEN;

int pos = paint_rect.x1 + scal; int d = 0; ldiv_t res;

double dx = grid_data.dx; double x = grid_data.xmin + dx;

pb->Canvas->Font->Size = 7; pb->Canvas->Font->Color = clBlue;

for (int i = 1; i <= LEN; i++)

{

res = ldiv(i, 10); if (res.rem) d = 4; else d = 7;

if (d == 7)

{

pb->Canvas->Pen->Color = clGray; pb->Canvas->MoveTo(pos, paint_rect.y2);

pb->Canvas->LineTo(pos, paint_rect.y1); pb->Canvas->Pen->Color = clBlack;

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

pb->Canvas->MoveTo(pos, paint_rect.y2 - d); pb->Canvas->LineTo(pos, paint_rect.y2 + d);

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

pb->Canvas->TextOutA(pos-14, paint_rect.y2+d+2, FormatFloat("#.#E-0", x));

x += dx;

}

pb->Canvas->Pen->Color = clBlack; pb->Canvas->MoveTo(pos, paint_rect.y2 - d);

pb->Canvas->LineTo(pos, paint_rect.y2 + d); pos += scal;

}

scal = (paint_rect.y2 - paint_rect.y1) / 20; pos = paint_rect.y2;

double y = grid_data.ymin; double dy = grid_data.dy;

d = 5;

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

{

pb->Canvas->Pen->Color = clGray; pb->Canvas->MoveTo(paint_rect.x1, pos);

pb->Canvas->LineTo(paint_rect.x2, pos); pb->Canvas->Pen->Color = clBlack;

pb->Canvas->Pen->Width = 2; pb->Canvas->MoveTo(paint_rect.x1 - d, pos);

pb->Canvas->LineTo(paint_rect.x1 + d, pos); pb->Canvas->Pen->Width = 1;

pb->Canvas->TextOutA(paint_rect.x1-d-30, pos-10, FormatFloat("#.#E-0", y));

y += dy; pos -= scal;

}

pb->Canvas->Pen->Width = 2; pb->Canvas->MoveTo(paint_rect.x1, paint_rect.y1);

pb->Canvas->LineTo(paint_rect.x1, paint_rect.y2);

pb->Canvas->LineTo(paint_rect.x2, paint_rect.y2);

pb->Canvas->Pen->Width = 1; pb->Canvas->Font->Color = clInfoText;

pb->Canvas->Font->Size = 14;

int len = strlen(graph_data.graph_name) / 2 * 15 / 2;

int xpos = (paint_rect.x2 - paint_rect.x1) / 2 - len;

pb->Canvas->TextOutA(xpos, paint_rect.y1 - 25, graph_data.graph_name);

pb->Canvas->Font->Color = clBlack; pb->Canvas->Font->Size = 8;

pb->Canvas->TextOutA(paint_rect.x1 - 30, paint_rect.y1 - 15, graph_data.y_name);

len = strlen(graph_data.x_name) * 7; xpos = (paint_rect.x2 - len);

pb->Canvas->TextOutA(xpos, paint_rect.y2 - 20, graph_data.x_name);

}

void __fastcall TFormGraph::DrawGraphic()//sGraphData gd)

{

pb->Canvas->Pen->Width = pen_width; pb->Canvas->Pen->Color = graph_color;

pb->Canvas->Polyline(graph_data.point, LEN-1);

}

void __fastcall TFormGraph::bDynRangeClick(TObject *Sender)

{

grid = true; graph = true;

MainForm->GetGraphData(G_DYNAMIC_RANGE, graph_data, paint_rect, grid_data);

Repaint();

}

Листинг файла Definitions.h

#ifndef DefinitionsH

#define DefinitionsH

#include <ExtCtrls.hpp>

#include <stdio.h>

#include <stdlib.h>

#include <iostream.h>

#include <fstream.h>

#include <iomanip.h>

#include <system.hpp>

#include <math.h>

#include <math.hpp>

#include "ProgressBar.h"

const char

NAME_HEAD_DATA_FILE[] = "HeadData.dat",

NAME_USER_HEAD_DATA_FILE[] = "UserHeadData.dat",

NAME_TAPE_DATA_FILE[] = "TapeData.dat",

NAME_USER_TAPE_DATA_FILE[] = "UserTapeData.dat";

const int

HD_BL_WIDE = 0,

HD_INDUCT = 1,

HD_THICKNESS_PLATES_OF_CORE = 2,

HD_SPEC_ELECT_RES = 3,

HD_WIDTH_POLE_TIPS = 4,

HD_RAD_OF_POLE_TIPS = 5,

HD_MAGN_RES_OF_CORE = 6,

HD_MAGN_RES_OF_BL = 7,

HD_KOERC_FORCE = 8,

HD_INIT_MAGN_PERM = 9,

HD_MAX_MAGN_PERM = 10,

TD_THICKNESS_OF_WORK_LAYER = 11,

TD_MAX_MAGN_PERMEAB_OF_CARRIER = 12,

TD_INIT_MAGN_PERMEAB_OF_CARRIER = 13,

TD_RESIDUAL_MAGN = 14,

TD_KOERC_FORCE = 15,

TD_SB = 16,

TD_SM = 17,

CP_CURRENT = 18,

CP_NON_CONTACT_REC = 19,

CP_NON_CONTACT_REP = 20,

CP_CARRIER_SPEED = 21,

CP_AMP_RESIST = 22,

HD_NAME = 23,

TD_NAME = 24;

const double PI = 3.1415926535897932384626433832795;

const int G_AWC_CHANNEL_ON_FLOW = 0,

G_AWC_CHANNEL_ON_EDF = 1,

G_PWC_CHANNEL = 2,

G_PULS_CHARACT = 3,

G_FACT_OF_HARM = 4,

G_HEAD_FLOW = 5,

G_AWC_LAYER = 5,

G_PWC_LAYER = 6,

G_SENS = 7,

G_AMPLIT = 8,

G_EDF = 9,

G_DYNAMIC_RANGE = 10;

const int COUNT = 7, ARR_SIZE = 179, LEN = 180;

typedef struct tagRANGE_VAL {

double min; double max;

} sRANGE_VAL, *psRANGE_VAL;

typedef struct tagHD_RANGE {

sRANGE_VAL workBacklashWide; // ширина рабочего зазора

sRANGE_VAL inductance; // индуктивность

sRANGE_VAL thicknessPlatesOfCore; // толщина пластин сердечника

sRANGE_VAL specElecResOfMater; // удельное электрическое сопротивление материала

sRANGE_VAL koercForce; // коэрцитивная сила

sRANGE_VAL initMagnPermeab; // начальная магнитная проницаемость

sRANGE_VAL maxMagnPermeab; // максимальная магнитная проницаемость

} sHD_RANGE, *psHD_RANGE;

typedef struct tagTD_RANGE {

sRANGE_VAL thicknessOfWorkLayer; // толщина рабочего слоя

sRANGE_VAL maxMagnPermeabOfCarrier; // магнитная проницаемость носителя

sRANGE_VAL initMagnPermeabOfCarrier; // обратная магнитная проницаемость носителя

sRANGE_VAL residualMagn; // остаточная намагниченность

sRANGE_VAL koercForce; // коэрцитивная сила

sRANGE_VAL sb; // среднеквадр. отклон. полей Hb

sRANGE_VAL sm; // среднеквадр. отклон. полей Hc

} sTD_RANGE, *pTD_RANGE;

typedef struct tagCP_RANGE {

sRANGE_VAL nonContactRec; // неконтакт при записи

sRANGE_VAL nonContactRep; // неконтакт при воспроизведении

sRANGE_VAL speedOfMoveCarrier; // скорость движения носителя

sRANGE_VAL current;

sRANGE_VAL resistOfRepAmp;

} sCP_RANGE, *psCP_RANGE;

typedef struct tagHeadData {

char name[30];

double workBacklashWidth; // ширина рабочего зазора

double inductance; // индуктивность

double thicknessPlatesOfCore; // толщина пластин сердечника

double specElecResOfMater; // удельное электрическое сопротивление материала

double widthOfPoleTips; // ширина полюсных наконечников

double radiusOfPoleTips; // радиус закругления наконечников

double magnResOfCore; // магнитное сопротивление сердечника

double magnResOfBacklash; // магнитное сопротивление зазора

double koercForce; // коэрцитивная сила

double initMagnPermeab; // начальная магнитная проницаемость

double maxMagnPermeab; // максимальная магнитная проницаемость

} sHeadData, *psHeadData;

typedef struct tagTapeData {

char name[30];

double thicknessOfWorkLayer; // толщина рабочего слоя

double maxMagnPermeabOfCarrier; // магнитная проницаемость носителя

double initMagnPermeabOfCarrier; // обратная магнитная проницаемость носителя

double residualMagn; // остаточная намагниченность

double koercForce; // коэрцитивная сила

double sb; // среднеквадр. отклон. полей Hb

double sm; // среднеквадр. отклон. полей Hc

} sTapeData, *psTapeData;

typedef struct tagChParam {

double nonContactRec; // неконтакт при записи

double nonContactRep; // неконтакт при воспроизведении

double speedOfMoveCarrier; // скорость движения носителя

double alpha;

double current;

double betta;

double resistOfRepAmp;

} sChParam, *psChParam;

typedef struct tagGraphData {

TPoint point[LEN];

double xmin; double xmax;

double ymin; double ymax;

char graph_name[50];

char x_name[50]; char y_name[50];

int graph_type;

} sGraphData, *psGraphData;

typedef struct tagGridData {

double dx; double dy;

double xmin; double ymin;

} sGridData, *psGridData;

typedef struct tagData {

double x;

double y;

} sData, *psData;

typedef struct tagRect {

int x1;

int y1;

int x2;

int y2;

} sRect, *psRect;

inline double sqr(double a)

{

return (a*a);

}

void gUserKeyPress(char &Key, String s, int vrSelStart);

#endif

Листинг файла Definitions.cpp

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

#pragma hdrstop

#include <Classes.hpp>

#include "Definitions.h"

#pragma package(smart_init)

const char *STR_ARRAY[23] =

{"ширины рабочего зазора",

"индуктивности головки",

"толщины пластин сердечника",

"удельного электрического сопротивления материала",

"ширины полюсных наконечников",

"радиуса закругления полюсных наконечников",

"магнитного сопротивления сердечника",

"магнитного сопротивления зазора",

"коэрциативной силы",

"начальной магнитной проницаемости",

"максимальной магнитной проницаемости",

"толщины рабочего слоя",

"максимальной магнитной проницаемости носителя",

"начальной магнитной проницаемости носителя",

"остаточной намагниченности",

"коэрциативной силы",

"sb", "sm", "тока ВЧП",

"неконтакта при записи",

"неконтакта при воспроизведении",

"скорости движения носителя",

"сопротивления УВ"};

void gUserKeyPress(char &Key, String s, int vrSelStart)

{

const int I = 3; //I+1 = количество знаков после запятой

int vrPos, vrLength;

vrLength = s.Length(); //определяем длину текста

vrPos = AnsiPos(",", s); //проверяем наличие запятой

if (Key == '\b') return;

if (vrLength >= 15)

{

Key = 0;

return;

}

switch (Key)

{

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

{ //проверяем положение курсора и количество знаков после запятой

if ((vrPos > 0) && ((vrLength - vrPos) > I) && (vrSelStart >= vrPos))

Key = 0; //"погасить" клавишу */

} break;

case ',':

case '.':

{ //если запятая уже есть или запятую пытаются поставить перед

//числом или никаких цифр в поле ввода еще нет

if ((vrPos > 0) || (vrSelStart == 0) || (vrLength == 0))

Key = 0; //"погасить" клавишу

else

Key = ','; //всегда заменять точку на запятую

} break;

default : Key = 0; break;

}

}

Листинг файла Calculations.h

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

#ifndef CalculatingH

#define CalculatingH

#include "Definitions.h"

#include <stdlib.h>

enum eRET_VAL {RV_POZ, RV_NEG, RV_PN};

class cAccounts

{

private:

bool isPozitive; bool isNegative;

ofstream f; ofstream logFile;

sHeadData hd; sTapeData td; sChParam cp;

double y0[COUNT], dy[COUNT], x[LEN], ahx[LEN], adhx[LEN], ahy[LEN],

ro0[LEN], ex[LEN], sni[LEN], snr[LEN], smn[LEN], phin[LEN],

s1[LEN], s2[LEN], ps[LEN], sm[LEN], emf[LEN], exc[LEN*2],

awcChannelOnFlow[LEN], awcChannelOnEDF[LEN], pwcChannel[LEN],

pcChannel[LEN*2], facOfHarm[LEN],

imResidMagn[LEN], reResidMagn[LEN],

imFlow[LEN], reFlow[LEN], flow[LEN],

s11[LEN], s22[LEN],

awcCh[LEN], edf[LEN],

pwcHead[LEN], amplitude[LEN];

sGraphData awcChOnFlow, awcChOnEDF, pwcCh, harm;

sData awc_l[LEN], pwc_l[LEN], sens_l[LEN], puls_ch[LEN*2];

double dynamicRange[LEN];

double coreMagnFlow, H0;

double Hz(double x, double y);

double Hx(double x, double y);

double Hy(double x, double y);

double HX(double x, double y); // продольная составляющая поля

double HY(double x, double y); // перпендикулярная составляющая поля

double dHX(double x, double y); // производная Hx

double dHY(double x, double y); // производная Hy

double F(double x, double y); //

void Kadn(double dp, double y, double dy, double amu1,

double amu2, double sni[], double snr[]);

double CalcCentOfGrav(double *, double, int); // расчет центра тяжести

void CalcDRTF(double *, int, int, double, double, double&, double&);

// прямое и обратное преобразование Фурье

void SplitIntoLayers(); // разбиение на слои (равномерное)

void CalcLossesAtRep(double dp, double aksc, double aksg,

double s1[], double s2[], double ps[]);

void PrepearingData();

void CheckData(const double mas[]);

void CheckData(double mas1[], double mas2[], double mas3[]);

void Normalize(const double mas1[], double mas[]);

void Normalize(double mas1[], double mas2[], double mas3[]);

void CalcArr(double mas1[], double mas2[]);

double GetMin(const double mas[]);

double GetMax(const double mas[]);

void CalculatePoints(const double mas[], sGraphData &gd, sRect rect,

sGridData &grid_data, bool norm);

void CopyArr(const double curmas[], double destmas[]);

void CalculateDynamicRange();

double Current(double amp, double t);

public:

void CalculateGraphPoints(int type, sGraphData &graph_data,

sRect rect, sGridData &grid_data, bool norm = false);

int Calculate(char *filename = 0); // расчет всего

void MakeAccounts();

void LetArr(int valtype, double mas[]);

void GetData(sHeadData h);

void GetData(sTapeData t);

void GetData(sChParam p);

eRET_VAL CalculatePoints(bool norm, int type, sRect rect, TPoint points[]);

eRET_VAL CalculatePoints(bool norm, int type, sRect rect, TPoint p1[],

TPoint p2[], TPoint p3[],

double mas1[], double mas2[], double mas3[]);

};

double LossesInvertSelfMagnetic(double thickness,

double nonContact,

double convertiblePermeability,

double densityOfRec);

double LossesSlotHole(double, double);

double LossesSkew(double widthOfPoleTips,

double skewAngle, double densityOfRec);

double LossesHeadSizes(double, double);

double LossesNonUniformityOfWorkBacklash(double, double);

double LossesFrequency(double, double, double, double);

double LossesSelfMagnetic(double, double, double, double);

#endif

Листинг файла Calculations.cpp

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

#pragma hdrstop

#include "Calculating.h"

#pragma package(smart_init)

double cAccounts::HX(double x, double y)

{

return 1./PI*(atan((hd.workBacklashWidth + x) / y)+atan((hd.workBacklashWidth - x) / y));

}

double cAccounts::dHX(double x, double y)

{

return 1./PI*(y/(y*y+sqr(hd.workBacklashWidth+x))-y/(y*y+sqr(hd.workBacklashWidth-x)));

}

double cAccounts::HY(double x, double y)

{

return 1./(2.*PI)*log((y*y+sqr(hd.workBacklashWidth+x))/(y*y+sqr(hd.workBacklashWidth-x)));

}

double cAccounts::dHY(double x, double y)

{

return 1./PI*((hd.workBacklashWidth+x)/(y*y+sqr(hd.workBacklashWidth+x)) +

(hd.workBacklashWidth-x)/(y*y+sqr(hd.workBacklashWidth-x)));

}

double cAccounts::F(double x, double y)

{

return dHY(x,y) + 3.0*dHX(x,y);

}

double cAccounts::CalcCentOfGrav(double ex[], double dx, int len)

{

double exx[202], f1=0, f2=0, f3=0, f4=0, x1=0, x2=0;

for (int i=0; i<=len; i++) exx[i]=ex[i]*i;

for (int i=0; i<=len; i=i+2)

{

f1=f1+exx[i]; f2=f2+ex[i]; }

for (int i=1; i<=len; i=i+2)

{

f3=f3+exx[i]; f4=f4+ex[i];

}

x1=1*f1+4*f3-exx[1]-exx[len]; x2=2*f2+4*f4-ex[len]-ex[1];

return dx*x1/x2;

}

void cAccounts::CalcDRTF(double y[], int nmax, int i, double arg,

double dt, double& si, double& sr)

{

int nmac;

double w, w2, as, ac, d3r, d1r, d1i, d2, d3i, fih, c2, c1;

sr=si=0.; nmac=nmax-2; w=arg*i; w2=w*w; as=sin(w); ac=cos(w);

if ((w-0.1)<=0.0f)

{

d3r=d1r=ac/3.0f; d1i=-as/3.0f; d2=4.0f/3.0f;

}

else

{

d3r=d1r=2.0f*ac/w2+as*(1.0f-2.0f/w2)/w; d1i=-(as/w-as)/w; d2=4.0f*(as/w-ac)/w2;

}

d3i = -d1i;

for (int n = 0; n < nmac; n=n+2)

{

fih=w*n; c1=sin(fih); c2=cos(fih);

as=d1r*y[n]+d2*y[n+1]+d3r*y[n+2];

ac=d1i*y[n]+d3i*y[n+2]; si=si+c1*as+c2*ac; sr=sr+c2*as-c1*ac;

}

si=si*dt; sr=sr*dt;

}

void cAccounts::SplitIntoLayers()

{

for (int n = 0; n < COUNT; n++)

{

dy[n] = td.thicknessOfWorkLayer /(COUNT - 1);

y0[n] = cp.nonContactRec + n * td.thicknessOfWorkLayer / (COUNT - 1);

f<<"dy["<<n<<"] = "<<dy[n]<<" y0["<<n<<"] = "<<y0[n]<<endl;

}

}

void cAccounts::CalcLossesAtRep(double dp, double aksc, double aksg,

double s1[], double s2[], double ps[])

{

double om, f, akb, psb, akf, psf, tet, coc, tgg, s3, s4, s6, qe, c;

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

{

om = 2.0 * PI * dp * i; f = om * cp.speedOfMoveCarrier / 2.0 / PI;

akb = 1.0 / (1.0 + sqr(2.0 * PI * f * hd.inductance / cp.resistOfRepAmp));

psb = -atan(2.0 * PI * f * hd.inductance / cp.resistOfRepAmp);

if (f <= 0.0)

{

akf = 1.; psf = 0.; }

else

{

tet = 2.0 * PI * hd.thicknessPlatesOfCore *

sqrt((hd.maxMagnPermeab * f) / (hd.specElecResOfMater * 1.e+9));

coc = ((1.0/tet)*(sinh(tet) + sin(tet))) / (cosh(tet) + cos(tet));

tgg = (sinh(tet) - sin(tet)) / (sinh(tet) + sin(tet));

akf = (1.0 + aksc + aksg) /

sqrt(sqr(1.0+aksg + aksc/(coc*sqrt(1.+tgg*tgg))) +

sqr(aksc*tgg/(coc*sqrt(1.0+tgg*tgg))));

psf = atan((aksc * tgg / (coc * sqrt(1.0 + tgg*tgg))) /

(1.0 + aksg + aksc / (coc * sqrt(1.0 + tgg*tgg))));

}

if (om <= 0.0)

{

s6=1.0; s3=1.0;

}

else

{

s6 = 1.0 - exp(- om * hd.radiusOfPoleTips);

s4 = om * hd.widthOfPoleTips; s3 = sin(s4)/s4;

}

qe = s6 * s3; c = akb * akf * qe;

s1[i] = s1[i] * c; s2[i] = s2[i] * c; ps[i] = psb + psf;

}

}

void cAccounts::PrepearingData()

{

hd.workBacklashWidth *= 0.5e-6; hd.inductance *= 1.e-3;

hd.thicknessPlatesOfCore *= 1.e-3; hd.specElecResOfMater *= 1.e-4;

hd.widthOfPoleTips *= 0.5e-6; hd.radiusOfPoleTips *= 1.e-6;

hd.initMagnPermeab *= 1.e+3; hd.maxMagnPermeab *= 1.e+3;

td.thicknessOfWorkLayer *= 1.e-6; td.residualMagn *= 1.e+3;

td.koercForce *= 1.e+3; td.sb *= 1.e+3; td.sm *= 1.e+3;

cp.nonContactRec *= 1.e-6; cp.nonContactRep *= 1.e-6;

cp.speedOfMoveCarrier *= 1.e-2; cp.resistOfRepAmp *= 1.e-0;

cp.current *= 1.0e-3; cp.alpha = td.koercForce / (sqrt(2) * td.sb);

}

void cAccounts::Kadn(double dp, double y, double dy, double amu1,

double amu2, double sni[], double snr[])

{

double om, w, ad, an, b, s1, s2, thd, tha, s20;

for (int ip = 0; ip < LEN; ip++)

{

om=2.*PI*ip; w=om*y;

if ((w-17.)>0)

{

ad=0.; an=(amu2+1.)/(amu1+1.);

}

else

{

if (om<=1) b=0;

else

{

s1=om*dy; b=tanh(s1)/s1/(1.+(amu1+1.)/2./amu1*tanh(s1));

s1=om*dy/2.; b=1.-b*(1.+1./amu1*tanh(s1));

}

an=(amu2*b+1.)/(amu1*b+1.);

if (om<=0)

{

ad=1.; thd=0;

}

else

{

ad=1e-11; s1=om*y;

tha=tanh(s1); s1=om*dy;

thd=tanh(s1); s2=sqrt(1.-tha*tha);

if ((s2-1e-17)>0) ad=thd/s1*s2/(1.+tha+(1./amu2+amu2*tha)*thd);

s20=om*dy/2.; thd=tanh(s20);

}

ad=ad*(1.+1./amu2*thd);

}

sni[ip]=sni[ip]*ad*an; snr[ip]=snr[ip]*ad*an;

}

}

int cAccounts::Calculate(char *filename)

{

FormPrBar->GetString("Подождите, идут вычисления ...");

FormPrBar->Show();

FormPrBar->PrBar->Progress = 10; //10%

Application->ProcessMessages();

const F = 60e+3;

cp.betta = -cp.current*600*sin(2*PI*F)*1e+10/hd.workBacklashWidth;

int n = 0, i = 0, ip = 0;

double gam = 0.21333,

c = cp.alpha * cp.betta * gam,

akscr = hd.magnResOfCore / hd.magnResOfBacklash,

akcr = 1.0 /(1.0 + akscr),

heps = 0., exm = 0., xh = 0., q = 0., dx = 0., dp = 0., dp1 = 0., si = 0., sr = 0., r = 0.0f,

ak = 0.0f,dxm = 0.0f,eps1 = 0,xeps = 0, x1 = 0, x2 = 0, e = 0, x0 = 0, a1 = 0, a2 = 0, xm = 0,

smm = 0, emfm = 0;

double vel = cp.speedOfMoveCarrier;

String str = GetCurrentDir(); int len = str.Length();

str.Delete(len - 3, 4); str += "Data"; SetCurrentDir(str);

logFile.open("Calculate.log"); logFile<<"Вызов PrepearingData() ..."<<endl; logFile.close();

PrepearingData();

Application->ProcessMessages();

char *name = 0;

if (filename) name = filename; else name = "data.txt";

f.open(name, ios::app); f.setf(ios::scientific); f.precision(20);

FormPrBar->PrBar->Progress = 20; //20%

logFile.open("Calculate.log", ios::app);

logFile<<"Вызов функции SplitIntoLayers() (разбиение на слои) ..."<<endl; logFile.close();

SplitIntoLayers();

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет функции чувствительности слоев ..."<<endl; logFile.close();