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

#include <vcl.h>
#include <math.h>
#pragma hdrstop

#include "RackLoad.h"
#include "SelectMod_Param.h"
#include "ListConst.h"
#include "ProcExt.h"
#include "Data_Gen.h"
#include "message.h"
#include "Alinit.h"
#include "SelectMod_Param.h"
#include "pCanvas_func.h"
#include "alinit.h"
#include "SortP.h"
#include "TablZagr.h"
#include "String_doubleUnit.h"
#include "ZagrPlus.h"
#include "CombLoad.h"
#include "SelectProfilSect.h"


//#include "GrapFunc.h"

//#include "OutGraphic.h"

#define MAXLENGTH   10;       // Максимальный размер элемента в мм
#define N_BREAK     1000;      // Количество разбиений региона
#define RadMoment   30;
//#define SYMBCON     L"\u02DF"
#define SYMBCON     L"\u0007"

extern bool flag_image;


static int NAddFunc;
static double koeff_add[20][20];
static int num_fun[20][20];
static int n_fun[20];
//static int Nfun_Add;
static char nfu[8*1000];
static char nfu_add[8*20];
static bool flag_add;
static double MaxFun, MinFun;
static bool flag_constr = false;  // Флаг переключения кнопок закреплений


//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TRackLoadFrame *RackLoadFrame;


//---------------------------------------------------------------------------
__fastcall TRackLoadFrame::TRackLoadFrame(TComponent* Owner)
		: TFrame(Owner)
{
	 int rc;
	 Data = new TData3R;
	 Data->Color = clWhite;
	 NAddFunc=0;
	 index_portion = 0;  // размер массива регионов
	 Alloc_region(PORTION_REGION);
	 n_beam = 0;
	 k_beam = -1;
	 matr_result = NULL;
	 x_result = NULL;
	 Margins = 10;
	 HText = 10;
	 StepGrid = 20;
	 Len_XY = 0;
	 Step_up = 0;


	 StringGrid_Loads->ColCount = 6;
	 StringGrid_Loads->RowCount = 1;
	 StringGrid_Loads->Rows[0]->CommaText = "№, \"Отметка, м\", \"Q, кН\", \"N, кН\", \"My, кН*м\", \"e, мм\"";

	 /*
	 StringGrid_q->ColCount = 7;
	 StringGrid_q->RowCount = 1;
	 StringGrid_q->DefaultColWidth = 50;
	 StringGrid_q->ColWidths[1] = 100;
	 StringGrid_q->Rows[0]->CommaText = "№, \"X1, м\", \"X2, м\", \"q1, кН/м\", \"q2, кН/м\", \" \", \"b, мм\"";
	 */
	 StringGrid_N->ColCount = 6;
	 StringGrid_N->RowCount = 1;
	 StringGrid_N->Rows[0]->CommaText = "№, \"X1, м\", \"X2, м\", \"n_1, кН/м\", \"n_2, кН/м\", \"e, мм\"";

	 StringGrid_q->ColCount = 6;
	 StringGrid_q->RowCount = 1;
	 StringGrid_q->Rows[0]->CommaText = "№, \"X1, м\", \"X2, м\", \"q_1, кН/м\", \"q_2, кН/м\", \"e, мм\"";


	 StringGrid_Constr->ColCount = 5;
	 StringGrid_Constr->RowCount = 1;
	 StringGrid_Constr->Rows[0]->CommaText = "№, \"Отметка, м\", \"TX\", \"TZ\", \"RY\"";
	 ListBox1->Items->Clear();
	 ListBox1->Items->Add(L"Продольная сила N");
	 ListBox1->Items->Add(L"Перерезывающая сила Q");
	 ListBox1->Items->Add(L"Изгибающий момент My");
	 ListBox1->Items->Add(L"Прогиб \u03B4");
	 ListBox1->Items->Add(L"Напряжение в ц.т \u03c30");
	 ListBox1->Items->Add(L"Напряжение в правой точке \u03c31");
	 ListBox1->Items->Add(L"Напряжение в левой точке \u03c32");

	 StringGrid_koeff->Cells[0][0] = "Участок";
	 StringGrid_koeff->Cells[1][0] = "Отметка верха, м";
	 StringGrid_koeff->Cells[2][0] = L"\u03BC_XZ";
	 StringGrid_koeff->Cells[3][0] = L"\u03BC_XY";

	 StringGrid_koeff->RowCount = 2;
	 TabSheet_dummy->TabVisible = false;
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::ConfigForm_profil(int form_profil, TObject *Sender)
{

	Form_profil = form_profil;
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::InitRack(TObject *Sender)
{
	 int rc;
	 Length_rack = 0;
	 beam_mod.m_length = 0;
	 beam_mod.kp_length = 0;
	 beam_mod.q_length = 0;
	 beam_mod.EI_length = 0;
	 beam_mod.loads_length = 0;
	 beam_mod.constr_length = 0;
	 beam_mod.N_length = 0;
	 if (index_portion!=0) {
		 delete(EI);
		 delete(q_);
		 delete(N_);
		 delete(loads);
		 delete(constr);
		 delete(dist_eN);
		 delete(dist_eL);
	 }
	 if (SelectMod_ParamForm==NULL)
		 Application->CreateForm(__classid(TSelectMod_ParamForm), &SelectMod_ParamForm);
	 index_portion = PORTION_REGION;
	 EI = new BeamRegion[PORTION_REGION];  // Регионы поперечной жесткости
	 q_ = new BeamRegion[PORTION_REGION];  // Регионы погонной поперечной нагрузки
	 N_ = new BeamRegion[PORTION_REGION];  // Регионы эпюры продольных сил
	 loads = new Load[PORTION_REGION];       // Точки задания сосредоточенных нагрузок
	 constr = new Constraint[PORTION_REGION]; // Точки задания связей (опор)
	 dist_eN = new double[PORTION_REGION];
	 dist_eL = new double[PORTION_REGION];

	 flag_comb = false;
	 k_beam = 0;
	 n_beam = 0;
	 n_comb = 0;
	 Edit_num_zagr->Text = "0";

	 PageControl_Load->ActivePage = TabSheet_ConcentrLoad;
	 TabSheet_Combin->TabVisible = false;
	 PageControl_BoundCond->ActivePage = TabSheet_Load0;

	 type_region = -1;
	 SelectRow = 0;
	 Len_XY = 0;
	 Step_up = 0;
	 Step_comp_rack = Length_rack;
	 ALLOCMAT_(Combin_zagr, 1, 1);

	 NewBalka(Sender);
	 Edit_Length->Text = FloatToStr(Length_rack);
	 if (Length_rack==0) {
		PageControl_BoundCond->Visible = false;
		PageControl_TabLoads->Visible = false;
	 }
}
//-----------------------------------------------------------------------------
void __fastcall TRackLoadFrame::PutParamSect(GEOM_PARAM_SECT *param_sect)
{
   I_beam = param_sect->Izz;
   F_beam = param_sect->Ar;
   H_beam = param_sect->Hsect;
   Zct_beam = param_sect->Zct;
   IE_beam = I_beam*206000;
   FE_beam = F_beam*206000;
   FRo_beam = F_beam*7850*1e-6;  // кг/м
   for (int i=0; i<n_beam; i++) {
	 EI_v[i].begValue = EI_v[i].endValue = IE_beam;
   }

}
//-----------------------------------------------------------------------------
void __fastcall TRackLoadFrame::Fill_field(TObject *Sender)
{
	Edit_Length->Text = FloatToStr(Length_rack);
	ImageList1->GetBitmap(0, SpeedButton_Apply->Glyph);
	PageControl_BoundCond->Visible = true;
	PageControl_TabLoads->Visible = true;
	Edit_num_zagr->Text = IntToStr(n_beam);
	// Взять регионы из депозитария
	if (n_beam>0) {
	  ComboBox_num_zagr->Items->Clear();
	  for (int i=0; i<n_beam; i++)
		ComboBox_num_zagr->Items->Add(IntToStr(i+1));

	  // Взять регионы из депозитария
	  int rc = Get_beam_data(0);
	  if (rc>0)
		return;
	}
	ComboBox_num_zagr->ItemIndex = 0;
	ComboBox_num_zagrChange(Sender);
	if (n_comb > 0) {
		flag_comb = true;
		TabSheet_Combin->TabVisible = true;
		SpeedButton_CallCombin->Glyph->Width=0;
		ImageList1->GetBitmap(0, SpeedButton_CallCombin->Glyph);
	}
	else {
        flag_comb = false;
    }
	PageControl_BoundCondChange(Sender);
	Edit_step_down->Text = FloatToStr(Step_comp_rack);
}
//---------------------------------------------------------------------------
//
void __fastcall TRackLoadFrame::DrawOut(int nfun, int n_result, int *index)
{
	int i,j,k,m;
	int rc,n0,nSa;
    int  numr[100];
	double rez[1000];
	double *Sa;
	double **matr;
	double t0;
	double koeff;
	char str[240];
	char str0[24];
	int  flagSa;
	char funSa[24];
	double sa_max;
    TColor LineColor[]={clTeeColor, clTeeColor, clTeeColor, clTeeColor,
	clTeeColor, clTeeColor, clTeeColor, clTeeColor};
	String Title_Ax[] = {L"N, Н", L"Q, Н", L"My, Н\u00B7м", L"\u03B4, мм", L"\u03c30, МПа", L"\u03c31, МПа", L"\u03c32, МПа"};


	//koeff = strtod(((AnsiString)ComboBoxKoeff->Text).c_str(),NULL);
	koeff = 1;
		Series1->LinePen->Width=CSpinEditLineWidth->Value;
		Series2->LinePen->Width=CSpinEditLineWidth->Value;
		Series3->LinePen->Width=CSpinEditLineWidth->Value;
		Series4->LinePen->Width=CSpinEditLineWidth->Value;
		Series5->LinePen->Width=CSpinEditLineWidth->Value;
		Series6->LinePen->Width=CSpinEditLineWidth->Value;
		Series7->LinePen->Width=CSpinEditLineWidth->Value;
		Series8->LinePen->Width=CSpinEditLineWidth->Value;
        if (Data->Color!=clWhite) {
		   LineColor[0]=Data->Color;
		   LineColor[1]=Data->Color;
           LineColor[2]=Data->Color;
           LineColor[3]=Data->Color;
           LineColor[4]=Data->Color;
           LineColor[5]=Data->Color;
		   LineColor[6]=Data->Color;
		   LineColor[7]=Data->Color;
		}
		Series1->Clear();
		Series2->Clear();
		Series3->Clear();
		Series4->Clear();
		Series5->Clear();

	   for(i=0; i<n_result; i++) {
		  Series1->AddXY(x_result[i], matr_result[i][index[0]]*koeff,"",  LineColor[0]);
		  if (n_fun == 1) continue;
		  Series2->AddXY(x_result[i], matr_result[i][index[1]]*koeff,"",  LineColor[1]);
		  if (n_fun == 2) continue;
          Series3->AddXY(x_result[i], matr_result[i][index[2]]*koeff,"",  LineColor[2]);
          if (n_fun == 3) continue;
		  Series4->AddXY(x_result[i], matr_result[i][index[3]]*koeff,"",  LineColor[3]);
		  if (n_fun == 4) continue;
		  Series5->AddXY(x_result[i], matr_result[i][index[4]]*koeff,"",  LineColor[4]);
       }
	   Chart1->Title->Text->Clear();
	   //sprintf(str,"%s: max=%g, x=%g;  min=%g, x=%g",
	   //		   ListBox1->Items->Strings[index[0]].c_str(),
	   //		   koeff*Max_Value[index[0]], Round(Max_X[index[0]], 0),
	   //		   koeff*Min_Value[index[0]], Round(Min_X[index[0]], 0));
	   sprintf(str,", max=%g, x=%g;  min=%g, x=%g",
			   koeff*Max_Value[index[0]], Round(Max_X[index[0]], 0),
			   koeff*Min_Value[index[0]], Round(Min_X[index[0]], 0));
	   Chart1->Title->Text->Add(ListBox1->Items->Strings[index[0]]+ AnsiString(str));
	   Chart1->LeftAxis->Title->Caption = Title_Ax[index[0]];
	   Chart1->LeftAxis->Title->Angle = 0;

	   Repaint();
}
//---------------------------------------------------------------------------


void __fastcall TRackLoadFrame::ComboBoxKoeffChange(TObject *Sender)
{
    if  (n_fun>0) {
	  DrawOut(n_fun, n_result, index_fun);
    }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::CSpinEditLineWidthChange(TObject *Sender)
{
      int j;
	  DrawOut(n_fun, n_result, index_fun);

}
//
void __fastcall TRackLoadFrame::BitBtn_AddClick(TObject *Sender)
{
   int rc;
   // Вставить данные в следующую строку таблицы StringGrid_param
   InsertToGridFromText(-1);
  // Прочитать данные из таблицы и сформировать регионы
   rc = LoadDataFromGrid_param();
   if (rc>0) return;

   //Draw_beam();
}
//-----------------------------------------------------------------------------
// Вставить данные в k-ю строку таблицы
void __fastcall TRackLoadFrame::InsertToGridFromText(int index_row) {
   int rc, j, k;
   double x0, x1, p1, p2;
   double pz, px, my, exc = 0;
   char stroka[120];
   BeamRegion br;
   Load ld;
   Constraint cn;
   double x20;

   n_fun = 0;
   n_result = 0;

   if (type_region<0) {
	  rc=Application->MessageBox(L"RackLoadFrame:InsertToGridFromText: Прогаммная ошибка: type_region<0", L" ",
						  MB_OK | MB_ICONERROR);
      return;
   }
   if (type_region<=typeDistrN) {
	  switch (type_region) {
	  case typeLinearLoad:
		if (index_row<0)
		  k = StringGrid_q->RowCount - 1;
		else
		  k = index_row - 1;
	  // вычисляем координату последнего участка x20
		if (k>0) {
		  rc = String_double_zero_plus(StringGrid_q->Cells[1][0], StringGrid_q->Cells[1][k], &x0);
		  if (rc>0) return;
		  rc = String_double_zero_plus(StringGrid_q->Cells[1][0], StringGrid_q->Cells[2][k], &x1);
		  if (rc>0) return;
		  x20 = x1;
		}
		else
		  x20 = 0;
		rc = String_double_zero_plus(Label_x0->Caption, Edit_x0->Text, &x0);
		if (rc>0) return;
		rc = String_double_zero_plus(Label_x1->Caption, Edit_Len->Text, &x1);
		if (rc>0) return;
		rc = String_double(Label_p1->Caption, Edit_p1->Text, &p1);
		if (rc>0) return;
		rc = String_double(Label_p1->Caption, Edit_p2->Text, &p2);
		if (rc>0) return;
		exc = 0;
	  break;
	  case typeDistrN:
		if (index_row<0)
		  k = StringGrid_N->RowCount - 1;
		else
		  k = index_row - 1;
	  // вычисляем координату последнего участка x20
		if (k>0) {
		  rc = String_double_zero_plus(StringGrid_N->Cells[1][0], StringGrid_N->Cells[1][k], &x0);
		  if (rc>0) return;
		  rc = String_double_zero_plus(StringGrid_N->Cells[1][0], StringGrid_N->Cells[2][k], &x1);
		  if (rc>0) return;
		  x20 = x1;
		}
		else
		  x20 = 0;
		rc = String_double_zero_plus(Label_x0n->Caption, Edit_x0n->Text, &x0);
		if (rc>0) return;
		rc = String_double_zero_plus(Label_x1n->Caption, Edit_Len_n->Text, &x1);
		if (rc>0) return;
		rc = String_double(Label_p1->Caption, Edit_n1->Text, &p1);
		if (rc>0) return;
		rc = String_double(Label_p1->Caption, Edit_n2->Text, &p2);
		if (rc>0) return;
		rc = String_double(Label_excentr_N->Caption, Edit_excentr_N->Text, &exc);
		if (rc>0) return;
	  break;
	  }
	  if (x0 < x20) {
			rc = Application->MessageBox(("На этом участке нагрузка уже задана. Координата начала участка не должна быть меньше координаты конца предыдущего участка ("+
										  FloatToStr(x20)+")").c_str(),
						  L" ", MB_OK | MB_ICONERROR);
			return;
	  }
	  if (x1 <= x0) {
		 rc = Application->MessageBox(("На этом участке нагрузка уже задана. Координата конца участка должна быть больше координаты начала участка "+
										  FloatToStr(x0)).c_str(),
						  L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  if (type_region>typeEI) {
		if (x1 > CalcLengthBeam()) {
		  rc = Application->MessageBox(("Координата конца участка выходит за пределы стойки, длина которой равна "+FloatToStr(Length_rack)).c_str(),
						  L" ", MB_OK | MB_ICONERROR);
		  return;
		}
	  }
	  br.X0 = x0;
	  br.Len = x1-x0;
	  br.begValue = p1;
	  br.endValue = p2;

	  BeamRegionToGrid_param(type_region, br, index_row, exc);

	  //Edit_x0->Text = FloatToStr(x0 + Len);
   }
   else {
	  double xi;
	  if (type_region==typeConcentrLoad) {
		rc = String_double_zero_plus(Label_X0Load->Caption, Edit_X0Load->Text, &x0);
		if (rc>0) return;
		rc = String_double(Label_Fz->Caption, Edit_Fz->Text, &pz);
		if (rc>0) return;
		rc = String_double(Label_Fx->Caption, Edit_Fx->Text, &px);
		if (rc>0) return;
		rc = String_double(Label_My->Caption, Edit_My->Text, &my);
		if (rc>0) return;
		rc = String_double(Label_excentr_Load->Caption, Edit_excentr_Load->Text, &exc);
		if (rc>0) return;
		if (pz == 0 && px==0 && my==0) {
			rc = ApplicationMessageBox("Значение сил и момента не могут одновременно задаваться нулевыми",
						  " ", MB_OK | MB_ICONERROR);
			return;
		}
		if (x0 > CalcLengthBeam()) {
		  rc = Application->MessageBox(("Значение позиции выходит за пределы стойки, длина которой равна "+FloatToStr(Length_rack)+
										" м.").c_str(), L" ", MB_OK | MB_ICONERROR);
			return;
		}

		for (int i=1; i<StringGrid_Loads->RowCount; i++) {
		  if (i==index_row)
			  continue;
		  rc = String_double_zero_plus(StringGrid_Loads->Cells[1][0], StringGrid_Loads->Cells[1][i], &xi);
		  if (rc>0) return;
		  if ((ABS(x0 - xi))<1e-3) {
		  rc = Application->MessageBox((L"В загружении уже есть нагрузки в позиции "+FloatToStr(xi)).c_str(), L" ", MB_OK | MB_ICONERROR);
			return;
		  }
		}
		ld.X = x0;
		ld.u = px;
		ld.v = pz;
		ld.c = my;
		LoadToGrid_param(ld, index_row, exc);
	  }
	  if (type_region==typeConstraint) {
		if (!CheckBox_Tx->Checked && !CheckBox_Tz->Checked && !CheckBox_Ry->Checked) {
			rc = ApplicationMessageBox("Ни одна степень свободы не закреплена",
						  " ", MB_OK | MB_ICONERROR);
			return;
		}
		rc = String_double_zero_plus(Label_X0Constr->Caption, Edit_X0Constr->Text, &x0);
		if (rc>0) return;
		if (x0 > CalcLengthBeam()) {
		  rc = Application->MessageBox(("Значение позиции выходит за пределы стойки, длина которой равна "+FloatToStr(Length_rack)).c_str(),
						  L" ", MB_OK | MB_ICONERROR);
		  return;
		}
		for (int i=1; i<StringGrid_Constr->RowCount; i++) {
		  if (i==index_row)
			  continue;
		  rc = String_double_zero_plus(StringGrid_Constr->Cells[1][0], StringGrid_Constr->Cells[1][i], &xi);
		  if (rc>0) return;
		  if ((ABS(x0 - xi))<1e-3) {
		  rc = Application->MessageBox((L"В модели уже есть опора в позиции " + FloatToStr(xi)
										+ ". Заместить?").c_str(), L" ", MB_YESNO | MB_ICONQUESTION);
			if (rc==IDNO)
			  return;
			else
              index_row = i;
		  }
		}
		cn.X = x0;
		if (CheckBox_Tx->Checked)
		  cn.u = 1e30;
		else
		  cn.u = 0;
		if (CheckBox_Tz->Checked)
		  cn.v = 1e30;
		else
		  cn.v = 0;
		if (CheckBox_Ry->Checked)
		  cn.c = 1e30;
		else
		  cn.c = 0;
		ConstraintToGrid_param(cn, index_row);
	  }
	}
}
//---------------------------------------------------------------------------
// Подсчет длины стойки
double __fastcall TRackLoadFrame::CalcLengthBeam()
{
   int rc;
   double ss;

   return Length_rack;
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::BeamRegionToGrid_param(int type_region, BeamRegion br, int index_row, double exc)
{
   int k, rc;
   double x0, x1, Len;
   switch (type_region) {
   case typeLinearLoad:
	  if (index_row<0)  {  // добавить в конец
		 StringGrid_q->RowCount++;
		 k = StringGrid_q->RowCount - 1;
	  }
	  else {
		 k = index_row;
	  }
	  StringGrid_q->Cells[0][k] = k;
	  StringGrid_q->Cells[1][k] = br.X0;
	  StringGrid_q->Cells[2][k] = br.X0 + br.Len;
	  StringGrid_q->Cells[3][k] = br.begValue;
	  StringGrid_q->Cells[4][k] = br.endValue;
	  StringGrid_q->Cells[5][k] = "-";
   break;
   case typeDistrN:
	  if (index_row<0)  {  // добавить в конец
		 StringGrid_N->RowCount++;
		 k = StringGrid_N->RowCount - 1;
	  }
	  else {
		 k = index_row;
	  }
	  StringGrid_N->Cells[0][k] = k;
	  StringGrid_N->Cells[1][k] = br.X0;
	  StringGrid_N->Cells[2][k] = (br.X0 + br.Len);
	  StringGrid_N->Cells[3][k] = br.begValue;
	  StringGrid_N->Cells[4][k] = br.endValue;
	  StringGrid_N->Cells[5][k] = exc;
   break;

   }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::LoadToGrid_param(Load ld, int index_row, double exc)
{
   int k;
	  if (index_row <0) {
		StringGrid_Loads->RowCount++;
		k = StringGrid_Loads->RowCount - 1;
	  }
      else
		k = index_row;
	  StringGrid_Loads->Cells[0][k] = k;
	  StringGrid_Loads->Cells[1][k] = ld.X;
	  StringGrid_Loads->Cells[2][k] = ld.v;
	  StringGrid_Loads->Cells[3][k] = ld.u;
	  StringGrid_Loads->Cells[4][k] = ld.c;
	  StringGrid_Loads->Cells[5][k] = exc;
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::ConstraintToGrid_param(Constraint cn, int index_row)
{
   int k;
	  if (index_row <0) {
		StringGrid_Constr->RowCount++;
		k = StringGrid_Constr->RowCount - 1;
      }
	  else
        k = index_row;
	  StringGrid_Constr->Cells[0][k] = k;
	  StringGrid_Constr->Cells[1][k] = cn.X;
	  if (cn.u==1e30)
		  //StringGrid_Constr->Cells[3][k] = SYMBCON;
		  StringGrid_Constr->Cells[2][k] = SYMBCON;
	  else
		  //StringGrid_Constr->Cells[3][k] =" ";
		  StringGrid_Constr->Cells[2][k] =" ";
	  if (cn.v==1e30)
		  //StringGrid_Constr->Cells[2][k] = SYMBCON;
		  StringGrid_Constr->Cells[3][k] = SYMBCON;
	  else
		  //StringGrid_Constr->Cells[2][k] =" ";
		  StringGrid_Constr->Cells[3][k] =" ";
	  if (cn.c==1e30)
		  StringGrid_Constr->Cells[4][k] = SYMBCON;
	  else
		  StringGrid_Constr->Cells[4][k] =" ";
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::CheckBox_LinearClick(TObject *Sender)
{
	if (CheckBox_Linear->Checked) {
	  Label_p2->Visible = true;
	  Edit_p2->Visible = true;
	}
	else {
	  Label_p2->Visible = false;
	  Edit_p2->Visible = false;
	  Edit_p2->Text = Edit_p1->Text;
	}
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::Edit_p1Change(TObject *Sender)
{
   if (!CheckBox_Linear->Checked) {
	  Edit_p2->Text = Edit_p1->Text;
   }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::BitBtn_CalculateClick(TObject *Sender)
{
	 // Здесь читаются данные из StringGrid_param текущего загружения
	 //PageControl_BoundCondChange(Sender);
     k_result = 0;
	 // Записать текущее загружение - оно записывается в ComboBox_num_zagr_rezChange
	 if (beam_mod.EI_length != 0 && Length_rack > 0) {
		 Put_beam_data();
	 }
	 //-----------------------------------------------------------------
	 if (beam_mod.constr_length == 0) {
		 int rc = ApplicationMessageBox("На стойке не заданы опоры",
						  " ", MB_OK | MB_ICONERROR);
		 PageControl_BoundCond->ActivePage = TabSheet_Constr_Raskrep;

		 return;
	 }

	 ListBox1->Selected[0]=true;
	 PageControl1->ActivePage = TabSheetResult;
	 // Здесь вызывается DrawOut
	 //ListBox1Click(Sender);
	 ComboBox_num_zagr_rez->Items->Clear();
	 for (int i=0; i<n_beam; i++) {
		  ComboBox_num_zagr_rez->Items->Add(L"Загружение "+IntToStr(i+1));
	 }
	 for (int i=0; i<n_comb; i++) {
		  ComboBox_num_zagr_rez->Items->Add(L"Сочетание "+IntToStr(i+1));
	 }
	 ComboBox_num_zagr_rez->ItemIndex = 0;
     // Здесь выполняется анализ загружения
	 ComboBox_num_zagr_rezChange(Sender);
}
//---------------------------------------------------------------------------
// Выполнить расчет загружения
void __fastcall TRackLoadFrame::CalculateExecute(int k_beam, bool flag_out, double *q_down, double *q_down_LR, double *M_down_LR, TObject *Sender)
{

	 int rc, i;
	 char stroka[240];
	 double MaxLength;
	 int N_break;
	 double *Xsort;
	 int *index;
	 BeamRegion q_double[PORTION_REGION];
	 Load       loads_exc[PORTION_REGION];
	 BeamRegion mz_exc[PORTION_REGION];


	 //BeamRegion* EI_0;  // Регионы поперечной жесткости
	 //BeamRegion* q_0;  // Регионы погонной поперечной нагрузки
	 //BeamRegion* N_0;  // Регионы эпюры продольных сил
	 //Load*    loads_0;         // Точки задания сосредоточенных нагрузок
	 //Constraint* constr_0;     // Точки задания связей (опор)

	 //EI_0 = new BeamRegion[PORTION_REGION];  // Регионы поперечной жесткости
	 //q_0 = new BeamRegion[PORTION_REGION];  // Регионы погонной поперечной нагрузки
	 //N_0 = new BeamRegion[PORTION_REGION];  // Регионы эпюры продольных сил
	 //loads_0 = new Load[PORTION_REGION];       // Точки задания сосредоточенных нагрузок
	 //constr_0 = new Constraint[PORTION_REGION]; // Точки задания связей (опор)

	 if (beam_mod.q_length == 0 && beam_mod.N_length == 0 && beam_mod.loads_length == 0) {
		 rc = Application->MessageBox((L"В загружении "+IntToStr(k_beam+1)+L" не задан ни один из видов нагрузки").c_str(),
						  L" ", MB_OK | MB_ICONERROR);
		 return;
	 }

	 MaxLength = MAXLENGTH;
	 MaxLength /= L1000;
	 N_break = N_BREAK;


	   int ku = 0;
	   int kv = 0;
	   int kc = 0;
	   for (int i = 0; i<beam_mod.constr_length; i++) {
		 if (constr[i].u!=0) ku ++;
		 if (constr[i].v!=0) kv ++;
		 if (constr[i].c!=0) kc ++;
	   }
	   if (((kv >= 1 && kc >= 1) || kv >= 2) && ku>=1)
		 flag_rigid = false;
	   if (flag_rigid) {
		 rc = ApplicationMessageBox("Заданные опоры стойки не исключают перемещения твердого тела",
						  " ", MB_OK | MB_ICONERROR);
		 return;
	   }
	   if (beam_mod.q_length == 0) {
		 beam_mod.q_length = 1;
		 q_[0].X0 = 0;
		 q_[0].Len = 0;
		 q_[0].begValue = 0;
		 q_[0].endValue = 0;
	   }
	   if (beam_mod.N_length == 0) {
		 beam_mod.N_length = 1;
		 N_[0].X0 = 0;
		 N_[0].Len = 0;
		 N_[0].begValue = 0;
		 N_[0].endValue = 0;
	   }
	   if (beam_mod.loads_length == 0) {
		 beam_mod.loads_length = 1;
		 loads[0].X = 0;
		 loads[0].u = 0;
		 loads[0].v = 0;
		 loads[0].c = 0;
	   }
	   if (beam_mod.constr_length == 0) {
		 beam_mod.constr_length = 1;
		 constr[0].X = 0;
		 constr[0].u = 0;
		 constr[0].v = 0;
		 constr[0].c = 0;
	   }
	 // Сортировать нагрузки и закрепления по координатам
	   if (beam_mod.loads_length > 1) {
		 qsortkr((char*)loads, (char*)dist_eL, beam_mod.loads_length, sizeof(Load), (fptr)cmp_Load, WDOUBLE);
	   }
	   if (beam_mod.constr_length > 1) {
		 qsortk((char*)constr, beam_mod.constr_length, sizeof(Constraint), (fptr)cmp_Constraint);
	   }

	   // Установить максимальный размер элемента при разбиении
	   beam_mod.MultiSupportBeam_(N_break, MaxLength, H_beam, Zct_beam, I_beam, F_beam);


	   // НеУдвоение распределенных нагрузок в случае LR
	   memcpy(q_double, q_, sizeof(BeamRegion)*beam_mod.q_length);
	   *q_down = 0;
	   *q_down_LR = 0;
	   *M_down_LR = 0;


	   // Учет эксценриситета сосредоточенных нагрузок
	   memcpy(loads_exc, loads, sizeof(Load)*beam_mod.loads_length);
	   for (i=0; i<beam_mod.loads_length; i++) {
		 loads_exc[i].c += loads[i].u*dist_eL[i]*1e-3;
	   }
	   // Учет эксценриситета продольных нагрузок
	   memcpy(mz_exc, N_, sizeof(BeamRegion)*beam_mod.N_length);
	   beam_mod.m_length = beam_mod.N_length;
	   for (i=0; i<beam_mod.m_length; i++) {
		   mz_exc[i].begValue *= dist_eN[i];
		   mz_exc[i].endValue *= dist_eN[i];
	   }

	   // Расчет многоопорной стойки
	   rc = beam_mod.calculate(EI, N_, q_double, mz_exc, loads_exc, constr, FE_beam);          //EI[0]
	   if (rc>0) {
		  if (rc == beam_mod.ErrSingular) {
			i = ApplicationMessageBox("Для заданного распределения продольных усилий коэффициент критической нагрузки потери устойчивости по Эйлеру больше или равен 1.0", " ",
				   MB_OK | MB_ICONERROR);
		  }
		  else {
			i = Application->MessageBox(("При расчете стойки произошла программная ошибка с кодом "+IntToStr(rc)).c_str(), L" ",
				   MB_OK | MB_ICONERROR);
		  }
		  return;
	   }
	   // Восстановить исходные данные
	   rc = Get_beam_data(k_beam);
	   // Получить результаты на стойке
	   //int n_break = ceil(CalcLengthBeam()/MaxLength);   // Количество разбиений при выводе результатов
	   int n_break = N_break;   // Количество разбиений при выводе результатов
	   //GetResult(10*CalcLengthBeam()/MaxLength);
	   //GetResult(100*n_break);
	   GetResult(n_break);

		 // Здесь вызывается DrawOut - вывод графиков
	   //----	 ListBox1Click(Sender);

		 PageControl1->ActivePage = TabSheetResult;

	   if (flag_out) {
		 double Lbeam = CalcLengthBeam();
		 // Вывод экстремумов и результатов на печать
		 printExtremum(beam_mod);

		 printResult(0);
		 printResult(Lbeam/2 - 1);
		 printResult(Lbeam/2);
		 printResult(Lbeam/2 + 1);
		 printResult(Lbeam);

		 for (int i=0; i < beam_mod.constr_force_length; i++) {
		   sprintf(stroka,"   координата %g: Rv=%g, Rc=%g ", beam_mod.ConstrForces[i].X,
			   beam_mod.ConstrForces[i].v, beam_mod.ConstrForces[i].c );
		   InfMessage((AnsiString)stroka);
		 }

	   }
}
//---------------------------------------------------------------------------
// Новое загружение - новое загружение (создается как новая стойка с сохранением длины и закреплений)
void __fastcall TRackLoadFrame::NewBalka(TObject *Sender)
{
	 int i, rc;

	 n_fun = 0;
	 n_result = 0;

	 if (beam_mod.EI_length != 0 && Length_rack > 0) {
		 // Записать текущее загружение.
		 Put_beam_data();
		 // Установить тип загружения
		 Set_type_zagr(k_beam);
		 // Установить коэфф. надежности
		 rc = String_double_plus(Label_gamma_f->Caption, Edit_gamma_f->Text, &(Koeff_gamma_f[k_beam]));
		 if (rc>0) return;
		 // Установить понижающий коэфф.
		 rc = String_double_plus(Label_koef_low->Caption, Edit_koef_low->Text, &(Koeff_low[k_beam]));
		 if (rc>0) return;
	 }

	 if (n_beam == MAX_BEAM_DATA) {
	   i = Application->MessageBox((L"Количество загружений достигло предельного количества " + IntToStr(n_beam)).c_str(), L" ",
		  MB_OK | MB_ICONERROR);
	   return;
	 }

	 k_beam = n_beam;

	 Label_Weight->Visible = false;

	 // Установить тип загружения
	 Set_type_zagr(k_beam);
	 // Установить коэфф. надежности
	 rc = String_double_plus(Label_gamma_f->Caption, Edit_gamma_f->Text, &(Koeff_gamma_f[k_beam]));
	 if (rc>0) return;
	 // Установить понижающий коэфф.
	 rc = String_double_plus_low(Label_koef_low->Caption, Edit_koef_low->Text, 1.0, &(Koeff_low[k_beam]));
	 if (rc>0) return;

	 ComboBox_num_zagr->Items->Clear();
	 for (i=0; i<=n_beam; i++) {
		ComboBox_num_zagr->Items->Add(IntToStr(i+1));
	 }

	 ComboBox_num_zagr->ItemIndex = k_beam;
	 ComboBox_num_zagr->Text = k_beam+1;

	 beam_mod.EI_length = 1;
	 beam_mod.q_length = 0;
	 beam_mod.N_length = 0;
	 beam_mod.loads_length = 0;
	 //beam_mod.constr_length = 0;
	 type_region = -1;
     if (index_portion!=0) {
		 delete(EI);
		 delete(q_);
         delete(N_);
		 delete(loads);
		 //delete(constr);
     }
     flag_rigid = true;
	 index_portion = PORTION_REGION;

	 EI = new BeamRegion[PORTION_REGION];  // Регионы поперечной жесткости
	 EI[0].begValue = IE_beam;
	 EI[0].endValue = IE_beam;

   //EI[0].begValue = 1e9;
   //EI[0].endValue = 1e9;

	 EI[0].X0 = 0;
	 EI[0].Len = Length_rack;
	 beam_mod.EI_length = 1;

     q_ = new BeamRegion[PORTION_REGION];  // Регионы погонной поперечной нагрузки
     N_ = new BeamRegion[PORTION_REGION];  // Регионы эпюры продольных сил
	 loads = new Load[PORTION_REGION];       // Точки задания сосредоточенных нагрузок
	 //constr = new Constraint[PORTION_REGION]; // Точки задания связей (опор)

	 //Edit_X0Constr->Text = 0;
	 //CheckBox_Tx->Checked = false;
	 //CheckBox_Tz->Checked = false;
	 //CheckBox_Ry->Checked = false;

	 Edit_X0Load->Text = 0;
	 Edit_Fz->Text = 0;
	 Edit_Fx->Text = 0;
	 Edit_My->Text = 0;
	 StringGrid_Loads->RowCount = 1;

	 Edit_x0->Text = 0;
	 Edit_Len->Text = 0;
	 Edit_p1->Text = 0;
	 Edit_p2->Text = 0;
	 StringGrid_q->RowCount = 1;

	 Edit_x0n->Text = 0;
	 Edit_Len_n->Text = 0;
	 Edit_n1->Text = 0;
	 Edit_n2->Text = 0;
	 StringGrid_N->RowCount = 1;

	 PageControl1->ActivePage = TabSheetSourse;
	 PageControl_Load->ActivePage = TabSheet_ConcentrLoad;
	 //PageControl_ParamChange(Sender);
	 PageControl_BoundCondChange(Sender);
	 CheckBox_LinearClick(Sender);
	 CheckBox_Linear_nClick(Sender);
}
//---------------------------------------------------------------------------
// Прочитать данные из табицы и сформировать регионы
int __fastcall TRackLoadFrame::LoadDataFromGrid_param()
{
   int i, k, rc;
   double F0, M0, FX, FZ, MY;
   double x0, x1, len, q1, q2, exc;
   char stroka[240];
   double x10;

   if (type_region >=0) {
	 *A_length = 0;
	 switch (type_region) {
	 case typeLinearLoad:
	   k = StringGrid_q->RowCount - 1;
	   x10 = 0;
	   for (i=0; i<k; i++) {
		 rc = String_double_zero_plus(StringGrid_q->Cells[1][0], StringGrid_q->Cells[1][i+1], &x0);
		 if (rc>0) return rc;
		 rc = String_double_plus(StringGrid_q->Cells[2][0], StringGrid_q->Cells[2][i+1], &x1);
		 if (rc>0) return rc;
		 len = x1 - x0;
		 rc = String_double(StringGrid_q->Cells[3][0], StringGrid_q->Cells[3][i+1], &q1);
		 if (rc>0) return rc;
		 rc = String_double(StringGrid_q->Cells[4][0], StringGrid_q->Cells[4][i+1], &q2);
		 if (rc>0) return rc;
		 //Arbit[i].X0 = y0;
		 //Arbit[i].Len = len;
		 //Arbit[i].begValue = q1;
		 //Arbit[i].endValue = q2;
		 q_[i].X0 = x0;
		 q_[i].Len = len;
		 q_[i].begValue = q1;
		 q_[i].endValue = q2;
		 x10 = x0 + len;
	   }
	   //*A_length = k;
	   beam_mod.q_length = k;
	 break;
	 case typeDistrN:
	   x10 = 0;
	   k = StringGrid_N->RowCount - 1;
	   for (i=0; i<k; i++) {
		 rc = String_double_zero_plus(StringGrid_N->Cells[1][0], StringGrid_N->Cells[1][i+1], &x0);
		 if (rc>0) return rc;
		 rc = String_double_plus(StringGrid_N->Cells[2][0], StringGrid_N->Cells[2][i+1], &x1);
		 if (rc>0) return rc;
		 len = x1 - x0;
		 rc = String_double(StringGrid_N->Cells[3][0], StringGrid_N->Cells[3][i+1], &q1);
		 if (rc>0) return rc;
		 rc = String_double(StringGrid_N->Cells[4][0], StringGrid_N->Cells[4][i+1], &q2);
		 if (rc>0) return rc;
		 rc = String_double(StringGrid_N->Cells[5][0], StringGrid_N->Cells[5][i+1], &exc);
		 if (rc>0) return rc;

		 N_[i].X0 = x0;
		 N_[i].Len = len;
		 N_[i].begValue = q1;
		 N_[i].endValue = q2;
		 dist_eN[i] = exc;
		 x10 = x0 + len;
	   }
	   //*A_length = k;
	   beam_mod.N_length = k;
	 break;
	 case typeConcentrLoad:  // Сосредоточенные нагрузки
	   k = StringGrid_Loads->RowCount - 1;
	   for (i=0; i<k; i++) {
		  rc = String_double_zero_plus(StringGrid_Loads->Cells[1][0], StringGrid_Loads->Cells[1][i+1], &x0);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[2][0], StringGrid_Loads->Cells[2][i+1], &FZ);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[3][0], StringGrid_Loads->Cells[3][i+1], &FX);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[4][0], StringGrid_Loads->Cells[4][i+1], &MY);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[5][0], StringGrid_Loads->Cells[5][i+1], &exc);
		  if (rc>0) return rc;

		  loads[i].X = x0;
		  loads[i].u = FX;
		  loads[i].v = FZ;
		  loads[i].c = MY;
		  dist_eL[i] = exc;
	   }
	   beam_mod.loads_length = k;
	 break;
	 case typeConstraint:  // Закрепления
	   k = StringGrid_Constr->RowCount - 1;
	   for (i=0; i<k; i++) {
		  rc = String_double_zero_plus(StringGrid_Constr->Cells[1][0], StringGrid_Constr->Cells[1][i+1], &x0);
		  if (rc>0) return rc;
		  //if (StringGrid_Constr->Cells[3][i+1]==SYMBCON)
		  if (StringGrid_Constr->Cells[2][i+1]==SYMBCON)
			constr[i].u = 1e30;
		  else
			constr[i].u = 0;
		  //if (StringGrid_Constr->Cells[2][i+1]==SYMBCON)
		  if (StringGrid_Constr->Cells[3][i+1]==SYMBCON)
			constr[i].v = 1e30;
		  else
			constr[i].v = 0;
		  if (StringGrid_Constr->Cells[4][i+1]==SYMBCON)
			constr[i].c = 1e30;
		  else
			constr[i].c = 0;
		  constr[i].X = x0;
	   }
	   beam_mod.constr_length = k;
	 break;
	 }
   }
   return 0;
}
//---------------------------------------------------------------------------
// Получить индекс по имени поля
int __fastcall TRackLoadFrame::GetIndexPlace(AnsiString place)
{
   if (place=="A") return 0;
   if (place=="U") return 1;
   if (place=="D") return 2;
   if (place=="LR") return 3;
   if (place=="L") return 4;
   if (place=="R") return 5;
   return -1;
}
//---------------------------------------------------------------------------
// Прочитать данные из таблицы и заполнить соответствующие поля
int __fastcall TRackLoadFrame::LoadDataFromGrid_ToText()
{
   int i, k, rc;
   double FX, FZ, MY;
   double x0, x1, len, q1, q2, n1, n2;
   double exc;

	i = SelectRow-1;

	switch (type_region) {
	case typeLinearLoad:
	   rc = String_double_zero_plus(StringGrid_q->Cells[1][0], StringGrid_q->Cells[1][i+1], &x0);
	   if (rc>0) return rc;
	   rc = String_double_plus(StringGrid_q->Cells[2][0], StringGrid_q->Cells[2][i+1], &x1);
	   if (rc>0) return rc;
	   len = x1 - x0;
	   rc = String_double(StringGrid_q->Cells[3][0], StringGrid_q->Cells[3][i+1], &q1);
	   if (rc>0) return rc;
	   rc = String_double(StringGrid_q->Cells[4][0], StringGrid_q->Cells[4][i+1], &q2);
	   if (rc>0) return rc;
	   Edit_x0->Text = x0;
	   Edit_Len->Text = x1;
	   Edit_p1->Text = q1;
	   Edit_p2->Text = q2;
	   if (q1 != q2) {
		 CheckBox_Linear->Checked = true;
	   }
	   else {
		 CheckBox_Linear->Checked = false;
	   }
	break;
	case typeDistrN:
	   rc = String_double_zero_plus(StringGrid_N->Cells[1][0], StringGrid_N->Cells[1][i+1], &x0);
	   if (rc>0) return rc;
	   rc = String_double_plus(StringGrid_N->Cells[2][0], StringGrid_N->Cells[2][i+1], &x1);
	   if (rc>0) return rc;
	   len = x1 - x0;
	   rc = String_double(StringGrid_N->Cells[3][0], StringGrid_N->Cells[3][i+1], &n1);
	   if (rc>0) return rc;
	   rc = String_double(StringGrid_N->Cells[4][0], StringGrid_N->Cells[4][i+1], &n2);
	   if (rc>0) return rc;
	   rc = String_double(StringGrid_N->Cells[5][0], StringGrid_N->Cells[5][i+1], &exc);
	   if (rc>0) return rc;
	   Edit_x0n->Text = x0;
	   Edit_Len_n->Text = x1;
	   Edit_n1->Text = n1;
	   Edit_n2->Text = n2;
	   Edit_excentr_N->Text = exc;
	   if (n1 != n2) {
		 CheckBox_Linear_n->Checked = true;
	   }
	   else {
		 CheckBox_Linear_n->Checked = false;
	   }
	break;
	case typeConcentrLoad:
		  rc = String_double_zero_plus(StringGrid_Loads->Cells[1][0], StringGrid_Loads->Cells[1][i+1], &x0);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[2][0], StringGrid_Loads->Cells[2][i+1], &FZ);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[3][0], StringGrid_Loads->Cells[3][i+1], &FX);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[4][0], StringGrid_Loads->Cells[4][i+1], &MY);
		  if (rc>0) return rc;
		  rc = String_double(StringGrid_Loads->Cells[5][0], StringGrid_Loads->Cells[5][i+1], &exc);
		  if (rc>0) return rc;
		  Edit_X0Load->Text = x0;
		  Edit_Fz->Text = FZ;
		  Edit_Fx->Text = FX;
		  Edit_My->Text = MY;
	      Edit_excentr_Load->Text = exc;

	break;
	case typeConstraint:  // Закрепления
		  rc = String_double_zero_plus(StringGrid_Constr->Cells[1][0], StringGrid_Constr->Cells[1][i+1], &x0);
		  if (rc>0) return rc;
		  //if (StringGrid_Constr->Cells[3][i+1]==SYMBCON) {
		  if (StringGrid_Constr->Cells[2][i+1]==SYMBCON) {
			constr[i].u = 1e30;
			CheckBox_Tx->Checked = true;
		  }
		  else {
			constr[i].u = 0;
			CheckBox_Tx->Checked = false;
		  }
		  //if (StringGrid_Constr->Cells[2][i+1]==SYMBCON) {
		  if (StringGrid_Constr->Cells[3][i+1]==SYMBCON) {
			constr[i].v = 1e30;
			CheckBox_Tz->Checked = true;
		  }
		  else  {
			constr[i].v = 0;
			CheckBox_Tz->Checked = false;
		  }
		  if (StringGrid_Constr->Cells[4][i+1]==SYMBCON)  {
			constr[i].c = 1e30;
			CheckBox_Ry->Checked = true;
		  }
		  else {
			constr[i].c = 0;
			CheckBox_Ry->Checked = false;
		  }
		  Edit_X0Constr->Text = FloatToStr(x0);
	  break;
	}
	return 0;
}
//-----------------------------------------------------------------------------
// Загрузить нагрузки данного загружения
void __fastcall TRackLoadFrame::GetRegion(int *k_zagr, int *length_q, BeamRegion **Aq, int *length_N, BeamRegion **AN,
										 int *length_loads, Load** Aloads, int *length_constr, Constraint** Aconstr,
										 double **exc_N, double **exc_L) {
	 if (beam_mod.EI_length != 0 && Length_rack > 0) {           //beam_mod.loads_length  beam_mod.q_length
	// Поместить регион в депозитарий
		 Put_beam_data();
	 }
	   *k_zagr = k_beam;
	   *Aq = q_;
	   *length_q = beam_mod.q_length;
	   *AN = N_;
	   *length_N = beam_mod.N_length;
	   *Aloads = loads;
	   *length_loads = beam_mod.loads_length;
	   *Aconstr = constr;
	   *length_constr = beam_mod.constr_length;
	   *exc_N = dist_eN;
	   *exc_L = dist_eL;
}
//-----------------------------------------------------------------------------
// Поместить данные регионов в таблицу
void __fastcall TRackLoadFrame::LoadDataToGrid_param(int type_param) {
   BeamRegion  *Arbit;
   int i;
   int length;
   if (type_param >=typeEI && type_param <= typeDistrN) {
	 switch (type_param) {
	 case typeEI:
	   Arbit = EI;
	   length = beam_mod.EI_length;
	   for (i=0; i<length; i++)
		 BeamRegionToGrid_param(type_region, Arbit[i], -1, 0.0);
	 break;
	 case typeLinearLoad:
	   Arbit = q_;
	   length = beam_mod.q_length;
	   for (i=0; i<length; i++)
		 BeamRegionToGrid_param(type_region, Arbit[i], -1, 0.0);
	 break;
	 case typeDistrN:
	   Arbit = N_;
	   length = beam_mod.N_length;
	   for (i=0; i<length; i++)
		 BeamRegionToGrid_param(type_region, Arbit[i], -1, dist_eN[i]);
	 break;
	 }
   }
   else {
	  if (type_param == typeConcentrLoad) {
		for (i=0; i<beam_mod.loads_length; i++) {
		  LoadToGrid_param(loads[i], -1, dist_eL[i]);
		}
	  }
	  if (type_param == typeConstraint) {  // Закрепления
		for (i=0; i<beam_mod.constr_length; i++) {
		  ConstraintToGrid_param(constr[i], -1);
		}
	  }
   }
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::printExtremum (MultiSupportBeam oneFE){
	char stroka[240];

	sprintf(stroka,"V max: Значение = %g при X = %g", oneFE.vmax.value, oneFE.vmax.XCoord);
	InfMessage((AnsiString)stroka);
	sprintf(stroka,"V min: Значение = %g при X = %g", oneFE.vmin.value, oneFE.vmin.XCoord);
	InfMessage((AnsiString)stroka);
	sprintf(stroka,"C max: Значение = %g при X = %g", oneFE.cmax.value, oneFE.cmax.XCoord);
    InfMessage((AnsiString)stroka);
	sprintf(stroka,"C min: Значение = %g при X = %g", oneFE.cmin.value, oneFE.cmin.XCoord);
    InfMessage((AnsiString)stroka);
    sprintf(stroka,"Q max: Значение = %g при X = %g", oneFE.Qmax.value, oneFE.Qmax.XCoord);
    InfMessage((AnsiString)stroka);
	sprintf(stroka,"Q min: Значение = %g при X = %g", oneFE.Qmin.value, oneFE.Qmin.XCoord);
    InfMessage((AnsiString)stroka);
    sprintf(stroka,"M max: Значение = %g при X = %g", oneFE.Mmax.value, oneFE.Mmax.XCoord);
    InfMessage((AnsiString)stroka);
    sprintf(stroka,"M min: Значение = %g при X = %g", oneFE.Mmin.value, oneFE.Mmin.XCoord);
    InfMessage((AnsiString)stroka);

}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::GetResult(int n_break){
    int i, rc, k, m, lres;
    double Lbeam, X;
	float del;

	m = 0;
	Lbeam = CalcLengthBeam();
	Lbeam *= L1000;
	lres = beam_mod.EI_length*n_break +
		   beam_mod.loads_length*2 +  beam_mod.constr_length*2;
    if (x_result!=NULL) {
	  FREEVEC_(x_result);
    }
	ALLOCVEC_(x_result, lres+10, float);

	for (i=0; i<beam_mod.EI_length; i++) {
	  del = EI[i].Len/n_break;
	  del *= L1000;
	  for (k=0; k<n_break; k++) {
		x_result[m] = EI[i].X0*L1000 + del*k;
        m++;
      }
	}
	for (i=0; i<beam_mod.loads_length; i++) {
		x_result[m] = loads[i].X*L1000;
		m++;
		x_result[m] = loads[i].X*L1000 + Lbeam/10000;
		m++;
    }
    for (i=0; i<beam_mod.constr_length; i++) {
		x_result[m] = constr[i].X*L1000;
        m++;
        x_result[m] = constr[i].X*L1000 + Lbeam/10000;
        m++;
    }
	qsortk((char*)x_result, m, sizeof(float), (fptr)cmpf);
	k = 0;
	for (i=1; i<m; i++) {
      if (x_result[i] > Lbeam)
         break;
	  if (x_result[k] != x_result[i]) {
         x_result[k+1] = x_result[i];
		 k++;
	  }
	}
    k++;
	// k - число точек
	k_result = k;
    if (matr_result!=NULL) {
	  FREEMAT_(matr_result);
    }
	//ALLOCMAT_F_(matr_result, k, 5);
	matr_result = (float**)almat_f(k, 7, &rc);
	if (rc>0) {
	   rc = Application->MessageBox(L"Error almat_f", L" ", MB_OK | MB_ICONERROR);
	   return;
	}

	for (i=0; i<7; i++) {
	  Max_Value[i] = -1e20;
	  Min_Value[i] = 1e20;
    }
	i = beam_mod.constr_force_length;
	double xR = beam_mod.ConstrForces[0].X;
	double UR = beam_mod.ConstrForces[0].u;
	double VR = beam_mod.ConstrForces[0].v;
	double CR = beam_mod.ConstrForces[0].c;
	for (i=0; i<k; i++) {
	  X = x_result[i];
	  matr_result[i][0] = beam_mod.getResults(X).N;
	  matr_result[i][1] = beam_mod.getResults(X).Q;
	  matr_result[i][2] = beam_mod.getResults(X).Mz/1000;
	  matr_result[i][3] = beam_mod.getResults(X).v;   //matr_result[500][3]
	  matr_result[i][4] = beam_mod.getResults(X).N/F_beam;
	  matr_result[i][5] = beam_mod.getResults(X).N/F_beam - beam_mod.getResults(X).Mz*Zct_beam/I_beam;
	  matr_result[i][6] = beam_mod.getResults(X).N/F_beam + beam_mod.getResults(X).Mz*(H_beam - Zct_beam)/I_beam;
	  //matr_result[i][3] = beam_mod.getResults(X).c*57.296;
	  if (Max_Value[0] < matr_result[i][0]) {   // Max N
		 Max_Value[0] = matr_result[i][0];
		 Max_X[0] = X;
	  }
	  if (Min_Value[0] > matr_result[i][0]) {   // Min N
		 Min_Value[0] = matr_result[i][0];
		 Min_X[0] = X;
	  }
	  if (Max_Value[4] < matr_result[i][4]) {   // Max sigma_цт
		 Max_Value[4] = matr_result[i][4];
		 Max_X[4] = X;
	  }
	  if (Min_Value[4] > matr_result[i][4]) {   // Min sigma_цт
		 Min_Value[4] = matr_result[i][4];
		 Min_X[4] = X;
	  }
	  if (Max_Value[5] < matr_result[i][5]) {   // Max sigma_up
		 Max_Value[5] = matr_result[i][5];
		 Max_X[5] = X;
	  }
	  if (Min_Value[5] > matr_result[i][5]) {   // Min sigma_up
		 Min_Value[5] = matr_result[i][5];
		 Min_X[5] = X;
	  }
	  if (Max_Value[6] < matr_result[i][6]) {   // Max sigma_down
		 Max_Value[6] = matr_result[i][6];
		 Max_X[6] = X;
	  }
	  if (Min_Value[6] > matr_result[i][6]) {   // Min sigma_down
		 Min_Value[6] = matr_result[i][6];
		 Min_X[6] = X;
	  }
	}
	n_result = k;

	Max_Value[1] = beam_mod.Qmax.value;
	Max_X[1] = beam_mod.Qmax.XCoord;
	Min_Value[1] = beam_mod.Qmin.value;
	Min_X[1] = beam_mod.Qmin.XCoord;

	Max_Value[2] = beam_mod.Mmax.value/1000;
	Max_X[2] = beam_mod.Mmax.XCoord;
	Min_Value[2] = beam_mod.Mmin.value/1000;
	Min_X[2] = beam_mod.Mmin.XCoord;

	Max_Value[3] = beam_mod.vmax.value;
	Max_X[3] = beam_mod.vmax.XCoord;
	Min_Value[3] = beam_mod.vmin.value;
	Min_X[3] = beam_mod.vmin.XCoord;

	Max_Value[0] = Round(Max_Value[0], 0);
	Min_Value[0] = Round(Min_Value[0], 0);

	Max_Value[1] = Round(Max_Value[1], 0);
	Min_Value[1] = Round(Min_Value[1], 0);

	Max_Value[2] = Round(Max_Value[2], 0);
	Min_Value[2] = Round(Min_Value[2], 0);

	Max_Value[3] = Round(Max_Value[3], 2);
	Min_Value[3] = Round(Min_Value[3], 2);

	Max_Value[4] = Round(Max_Value[4], 1);
	Min_Value[4] = Round(Min_Value[4], 1);

	Max_Value[5] = Round(Max_Value[5], 1);
	Min_Value[5] = Round(Min_Value[5], 1);

	Max_Value[6] = Round(Max_Value[6], 1);
	Min_Value[6] = Round(Min_Value[6], 1);

	/*
	Max_Value[4] = beam_mod.cmax.value;
	Max_X[4] = beam_mod.cmax.XCoord;
	Min_Value[4] = beam_mod.cmin.value;
	Min_X[4] = beam_mod.cmin.XCoord;
    */


}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::printResult(double X){
	char stroka[240];
     sprintf(stroka,"Q=%g, M=%g, R=%g, v=%g, c=%g", (beam_mod.getResults(X)).Q, (beam_mod.getResults(X)).Mz,
			(beam_mod.getResults(X)).R, (beam_mod.getResults(X)).v, (beam_mod.getResults(X)).c);
     InfMessage("Значения в точке "+FloatToStr(X)+": "+(AnsiString)stroka);
}
// Запись данных о стойке
// Чтение данных о стойке
// Размещение депозитария регионов
void __fastcall TRackLoadFrame::Alloc_region(int n_reg) {
	 EI_v = (BeamRegion*)calloc(n_reg, sizeof(BeamRegion));  // Регионы поперечной жесткости
	 q_v = (BeamRegion*)calloc(n_reg, sizeof(BeamRegion));  // Регионы погонной поперечной нагрузки
	 dist_eNv = (double*)calloc(n_reg, sizeof(double));  // эксцентриситеты
	 dist_eLv = (double*)calloc(n_reg, sizeof(double));  // эксцентриситеты
	 N_v = (BeamRegion*)calloc(n_reg, sizeof(BeamRegion));  // Регионы эпюры продольных сил
	 loads_v = (Load*)calloc(n_reg, sizeof(Load));       // Точки задания сосредоточенных нагрузок
	 //constr_v = (Constraint*)calloc(n_reg, sizeof(Constraint)); // Точки задания связей (опор)
	 Len_v = n_reg;

}
//---------------------------------------------------------------------------
// Повторное размещение депозитария регионов
void __fastcall TRackLoadFrame::ReAlloc_region(int n_reg) {
     Len_v += n_reg;
	 realloc(EI_v, n_reg*sizeof(BeamRegion));  // Регионы поперечной жесткости
	 realloc(q_v, n_reg*sizeof(BeamRegion));  // Регионы погонной поперечной нагрузки
	 realloc(dist_eNv, n_reg*sizeof(double));  // Эксцентриситеты
	 realloc(dist_eLv, n_reg*sizeof(double));  // Эксцентриситеты
	 realloc(N_v, n_reg*sizeof(BeamRegion));  // Регионы эпюры продольных сил
	 realloc(loads_v, n_reg*sizeof(Load));       // Точки задания сосредоточенных нагрузок
	 //realloc(constr_v, n_reg*sizeof(Constraint)); // Точки задания связей (опор)
}
//---------------------------------------------------------------------------
// Освобождение депозитария регионов
void __fastcall TRackLoadFrame::Free_region() {
     free(EI_v);
	 free(q_v);
	 free(N_v);
	 free(loads_v);
	 free(dist_eNv);
	 free(dist_eLv);
	 //free(constr_v);
}
//---------------------------------------------------------------------------
// Пеоместить регион в депозитарий
// Проверка и сдвиг региона
void __fastcall TRackLoadFrame::CheckRegion_at_Put(BeamRegion *P_v, int iP, int P_length, int k, int nP, double *e_v) {
   int i, shift;
   int iP_v = index_beam[k][nP];

   if (iP + P_length != iP_v) {
	  shift = iP + P_length - iP_v;
	  // Сдвиг
	  memcpy(P_v + iP_v + shift, P_v + iP_v, sizeof(BeamRegion)*(index_portion - (iP + iP_v + shift)));
	  if (nP==4) {     // сдвиг индексов и дистанций приложения продольной нагрзки
		memcpy(P_v + iP_v + shift, e_v + iP_v, sizeof(double)*(index_portion - (iP + iP_v + shift)));
	  }
	  for (i = k; i<n_beam; i++)
		index_beam[i][nP] += shift;
   }
}
//---------------------------------------------------------------------------
// Проверка и сдвиг нагрузок
void __fastcall TRackLoadFrame::CheckLoad_at_Put(Load *loads_v, int ild, int loads_length, int k, int nP, double *e_v) {
   int i, shift;

   if (ild + loads_length > index_beam[k][nP]) {
	  shift = ild + loads_length - index_beam[k][nP];
	  // Сдвиг
	  for (i = index_beam[n_beam-1][nP]-1; i >= index_beam[k][nP]; i--) {
		memcpy(loads_v + i + shift, loads_v + i, sizeof(Load));
	  }
	  for (i = k_beam + 1; i<n_beam; i++)
		 index_beam[i][nP] += shift;
   }
}
//---------------------------------------------------------------------------
// Проверка и сдвиг закреплений
void __fastcall TRackLoadFrame::CheckConstraint_at_Put(Constraint *P_v, int iP, int P_length, int k, int nP) {
   int i, shift;

   if (iP + P_length > index_beam[k][nP]) {
	  shift = iP + P_length - index_beam[k][nP];
	  // Сдвиг
	  for (i = index_beam[k_beam-1][nP]-1; i >= index_beam[k][nP]; i--) {
		memcpy(P_v+i+shift, P_v+i, sizeof(Constraint));
	  }
   }
}
//---------------------------------------------------------------------------
// Поместить регион в депозитарий
int __fastcall TRackLoadFrame::Put_beam_data() {
   int i, k, rc;
   int iEI, iq_, iN_, ild;
   //int icn, irep;

   k = k_beam;  // текущая стойка

   if (k==0) {
	 iEI = 0;
	 iq_ = 0;
	 iN_ = 0;
	 ild = 0;
	 //icn = 0;
   }
   else {
	 iEI = index_beam[k-1][0];
	 iq_ = index_beam[k-1][1];
	 iN_ = index_beam[k-1][4];
	 ild = index_beam[k-1][5];
	 //icn = index_beam[k-1][6];
   }
   AnsiString text = "";
rep:
   if (iq_ + beam_mod.q_length > Len_v)
	  text = "поперечных погонных";
   if (iN_ + beam_mod.N_length > Len_v)
	  text = "продольных распределенных";
   if (ild + beam_mod.loads_length > Len_v)
	  text = "сосредоточенных";
   if (text!="") {
	   i = Application->MessageBox((L"Нарушение программного ограничения. Суммарное количество "+text+" нагрузок превысило "+
								   IntToStr(Len_v)).c_str(), L" ",
								   MB_OK | MB_ICONERROR);
		  return 1;
   }

   // Проверка, не увеличилось ли количество регионов какого-либо из параметров
   //CheckRegion_at_Put(EI_v, iEI, beam_mod.EI_length, k, 0);
   //
   CheckRegion_at_Put(q_v, iq_, beam_mod.q_length, k, 1, NULL);
   CheckRegion_at_Put(N_v, iN_, beam_mod.N_length, k, 4, dist_eN);
   CheckLoad_at_Put(loads_v, ild, beam_mod.loads_length, k, 5, dist_eL);
   //
   //CheckConstraint_at_Put(constr_v, icn, beam_mod.constr_length, k, 6);

   EI[0].begValue = IE_beam;
   EI[0].endValue = IE_beam;

   memcpy(EI_v+iEI, EI, sizeof(BeamRegion)*beam_mod.EI_length);
   memcpy(q_v+iq_, q_, sizeof(BeamRegion)*beam_mod.q_length);
   memcpy(N_v+iN_, N_, sizeof(BeamRegion)*beam_mod.N_length);
   memcpy(dist_eNv+iN_, dist_eN, sizeof(double)*beam_mod.N_length);
   memcpy(loads_v+ild, loads, sizeof(Load)*beam_mod.loads_length);
   memcpy(dist_eLv+ild, dist_eL, sizeof(double)*beam_mod.loads_length);
   //memcpy(constr_v+icn, constr, sizeof(Constraint)*beam_mod.constr_length);

   index_beam[k][0] = iEI + beam_mod.EI_length;        // Конец
   index_beam[k][1] = iq_ + beam_mod.q_length;
   index_beam[k][4] = iN_ + beam_mod.N_length;
   index_beam[k][5] = ild + beam_mod.loads_length;
   //index_beam[k][6] = icn + beam_mod.constr_length;

   // Установить тип загружения
   Set_type_zagr(k_beam);
   // Установить коэфф. надежности
   rc = String_double_plus(Label_gamma_f->Caption, Edit_gamma_f->Text, &(Koeff_gamma_f[k_beam]));
   if (rc>0) return rc;
   // Установить понижающий коэфф.
   rc = String_double_plus(Label_koef_low->Caption, Edit_koef_low->Text, &(Koeff_low[k_beam]));
   if (rc>0) return rc;

   n_beam = MAX(n_beam, k+1);
   return 0;
}
//---------------------------------------------------------------------------
// Взять регионы из депозитария
int __fastcall TRackLoadFrame::Get_beam_data(int k) {
   int iEI, iq_, iN_, ild;
   //int icn;
   if (k > n_beam-1)
	  return 1;
   if (k==0) {
	 iEI = 0;
	 iq_ = 0;
	 iN_ = 0;
	 ild = 0;
	 //icn = 0;
   }
   else {
	 iEI = index_beam[k-1][0];
	 iq_ = index_beam[k-1][1];
	 iN_ = index_beam[k-1][4];
	 ild = index_beam[k-1][5];
	 //icn = index_beam[k-1][6];
   }
   beam_mod.EI_length = index_beam[k][0] - iEI;
   beam_mod.q_length = index_beam[k][1] - iq_;
   beam_mod.N_length = index_beam[k][4] - iN_;
   beam_mod.loads_length = index_beam[k][5] - ild;
   //beam_mod.constr_length = index_beam[k][6] - icn;

   memcpy(EI, EI_v+iEI, sizeof(BeamRegion)*beam_mod.EI_length);
   memcpy(q_, q_v+iq_, sizeof(BeamRegion)*beam_mod.q_length);
   memcpy(N_, N_v+iN_, sizeof(BeamRegion)*beam_mod.N_length);
   memcpy(dist_eN, dist_eNv+iN_, sizeof(double)*beam_mod.N_length);
   memcpy(loads, loads_v+ild, sizeof(Load)*beam_mod.loads_length);
   memcpy(dist_eL, dist_eLv+ild, sizeof(double)*beam_mod.loads_length);
   //memcpy(constr, constr_v+icn, sizeof(Constraint)*beam_mod.constr_length);

   // Установить тип загружения
   ComboBox_type_zagr->ItemIndex = type_zagr[k];
   // Установить коэфф. надежности
   Edit_gamma_f->Text = FloatToStr(Koeff_gamma_f[k]);
   // Установить понижающий коэфф.
   Edit_koef_low->Text = FloatToStr(Koeff_low[k]);
   // Установить флаг загружения от собственного веса
   if (flag_weight[k]) {
	 Label_Weight->Visible = true;
   }
   else {
	 Label_Weight->Visible = false;
   }

   return 0;
}
//---------------------------------------------------------------------------
// Удалить нагрузку из загружения
void __fastcall TRackLoadFrame::BitBtnDeleteClick(TObject *Sender)
{
	int i, k1, k0, j0, j;
	double x00, x0, x1, p1, p2, Len;
    char stroka[240];
    int rc;

	n_fun = 0;
	n_result = 0;
	switch (type_region) {
	case typeLinearLoad:
	k1 = SelectRow;
	k0 = StringGrid_q->RowCount;
	j0 = StringGrid_q->ColCount;
	if (k1>0) {
		for (i = k1+1; i<k0; i++) {
		  for (j=1; j<j0; j++) {
			StringGrid_q->Cells[j][i-1] = StringGrid_q->Cells[j][i];
		  }
		}
		StringGrid_q->RowCount--;
	}
	*A_length = StringGrid_q->RowCount-1;
	break;
	case typeDistrN:
	k1 = SelectRow;
	k0 = StringGrid_N->RowCount;
	j0 = 5;
	if (k1>0) {
		for (i = k1+1; i<k0; i++) {
		  for (j=1; j<j0; j++) {
			StringGrid_N->Cells[j][i-1] = StringGrid_N->Cells[j][i];
		  }
		}
		StringGrid_N->RowCount--;
	}
	*A_length = StringGrid_q->RowCount-1;
	break;
	case typeConcentrLoad:
	k1 = SelectRow;
	k0 = StringGrid_Loads->RowCount;
	j0 = 5;
	if (k1>0) {
		for (i = k1+1; i<k0; i++) {
		  for (j=1; j<j0; j++) {
			StringGrid_Loads->Cells[j][i-1] = StringGrid_Loads->Cells[j][i];
		  }
		}
		StringGrid_Loads->RowCount--;
	}
	*A_length = StringGrid_Loads->RowCount-1;
	break;
	case typeConstraint:
	k1 = SelectRow;
	k0 = StringGrid_Constr->RowCount;
	j0 = 5;
	if (k1>0) {
		for (i = k1+1; i<k0; i++) {
		  for (j=1; j<j0; j++) {
			StringGrid_Constr->Cells[j][i-1] = StringGrid_Constr->Cells[j][i];
		  }
		}
		StringGrid_Constr->RowCount--;
	}
	*A_length = StringGrid_Constr->RowCount-1;
	break;
	}
	// Прочитать данные из табицы и сформировать регионы
	rc = LoadDataFromGrid_param();
	if (rc>0) return;
	// Поместить регион в депозитарий
	Put_beam_data();

	//Draw_beam();
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::StringGrid_LoadsSelectCell(
      TObject *Sender, int ACol, int ARow, bool &CanSelect)
{
	  int rc;
	  SelectRow = ARow;
	  if (ARow>0) {
	  // Поместить данные строки таблицы в поля
		 rc = LoadDataFromGrid_ToText();
	  }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::Draw_beam() {
  float scale, scale_force, scale_kp, scale_q, scale_m, scale_N, Value;
  int i;
  double Width, Height;
  double L_beam, H_beam, H_beam1, H_beam2, B_beam, I_beam;
  TPoint points[10];
  TPoint vert[13];
  double zero_px, zero_py;


// Определить масштаб для рисования стойки
  Width = Image1->Width;
  Height = Image1->Height;

  L_beam = CalcLengthBeam();
  if (L_beam==0)
	return;

  H_beam = L_beam/30;
  I_beam = 0;
  for (i=0; i<beam_mod.EI_length; i++) {
	I_beam = MAX(I_beam, EI[i].begValue);
	I_beam = MAX(I_beam, EI[i].endValue);
  }
  if (I_beam==0)
    return;
  //B_beam = 12*I_beam/(pow(H_beam, 3.0));
  B_beam = 12*I_beam/(pow(H_beam, 2.0));
  scale = (Width - 60)/L_beam;

  //---------------------------------------------------
  Value = 0;
  for (i=0; i<beam_mod.loads_length; i++) {
     Value = MAX(Value, (ABS(loads[i].v)));
  }
  if (Value!=0)
     scale_force = (Height - 30)/(2*Value);
  else
	 scale_force = 0;
  //---------------------------------------------------
  Value = 0;
  for (i=0; i<beam_mod.q_length; i++) {
     Value = MAX(Value, (ABS(q_[i].begValue)));
     Value = MAX(Value, (ABS(q_[i].endValue)));
  }
  if (Value!=0)
	 scale_q = (Height - 30)/(4*Value);
  else
	 scale_q = 0;
  //---------------------------------------------------
  Value = 0;
  for (i=0; i<beam_mod.N_length; i++) {
	 Value = MAX(Value, (ABS(N_[i].begValue)));
	 Value = MAX(Value, (ABS(N_[i].endValue)));
  }
  if (Value!=0)
	 scale_N = (Height - 30)/(7*Value);
  else
     scale_N = 0;

  TRect NewRect = Rect(0, 0, Width, Height);

  pBrush_Color(Image1, clGray);
  //pBrush_Color(Image1, clBlack);
  pCanvas_FillRect(Image1, NewRect);
  zero_px = 30;
  zero_py = Height/2;
  // Рисование балки
  pBrush_Color(Image1, clGreen);
  pPen_Color(Image1, clLime);
  for (i=0; i<beam_mod.EI_length; i++) {
	H_beam1 = sqrt(12*EI[i].begValue/B_beam);
	H_beam2 = sqrt(12*EI[i].endValue/B_beam);
    //H_beam1 = pow(12*EI[i].begValue/B_beam, 1/3.0);
    //H_beam2 = pow(12*EI[i].endValue/B_beam, 1/3.0);
	points[0] = Point(zero_px+EI[i].X0*scale, zero_py-H_beam1*scale/2);
    points[1] = Point(points[0].x, zero_py+H_beam1*scale/2);
    points[2] = Point(points[0].x+EI[i].Len*scale, zero_py+H_beam2*scale/2);
	points[3] = Point(points[2].x, zero_py-H_beam2*scale/2);
    points[4] = points[0];
    pCanvas_Polygon(Image1, points, 4);
  }
  pPen_Color(Image1, clWhite);
  points[0] = Point(zero_px, zero_py);
  points[1] = Point(points[0].x + L_beam*scale, zero_py);
  pCanvas_Polyline(Image1, points, 1);
  // Рисование распределенных продольных нагрузок
  for (i=0; i<beam_mod.N_length; i++) {
    Draw_N(clNavy, clSkyBlue, N_, zero_px, zero_py, i, scale, scale_N, 40.0);
  }
  // Рисование опор
  for (i=0; i<beam_mod.constr_length; i++) {
	Draw_opora(zero_px, zero_py, i, scale);
  }
  // Рисование сосредоточенных нагрузок
  for (i=0; i<beam_mod.loads_length; i++) {
	Draw_load(zero_px, zero_py, i, scale, scale_force);
  }
  // Рисование погонных поперечных нагрузок
  for (i=0; i<beam_mod.q_length; i++) {
	Draw_q_or_kp("q=",clRed, 1.0, q_, zero_px, zero_py, i, scale, scale_q, 40.0);
  }
}
//-------------------------------------------------------------
#define  CONST_OPORA  21
void __fastcall TRackLoadFrame::Draw_opora(double zero_px, double zero_py, int i, float scale ) {
  TPoint points[10];
  TPoint point_0;

  point_0 = Point(zero_px + constr[i].X*scale, zero_py);
  // Рисование стойки
  pBrush_Color(Image1, clLtGray);
  pPen_Color(Image1, clBlue);
  if (constr[i].v!=0 && constr[i].c!=0) {  // заделка
	points[0] = Point(point_0.x, point_0.y - CONST_OPORA);
    points[1] = Point(point_0.x, point_0.y + CONST_OPORA);
    pCanvas_Polyline(Image1, points, 1);
    Shtrih(points, 7.0, -1.0, 1.0);
  }
  if (constr[i].v!=0 && constr[i].c==0) {  // шарнирная опора
    points[0] = Point(point_0.x, point_0.y);
	points[1] = Point(points[0].x + CONST_OPORA*0.5, point_0.y + CONST_OPORA);
	points[2] = Point(points[0].x - CONST_OPORA*0.5, point_0.y + CONST_OPORA);
    points[3] = points[0];
    pCanvas_Polygon(Image1, points, 3);
    Shtrih(points+1, 7.0, -1.0, 1.0);
  }
  if (constr[i].v==0 && constr[i].c!=0) {  //
    points[0] = Point(point_0.x - 5 , point_0.y - CONST_OPORA);
    points[1] = Point(point_0.x - 5 , point_0.y + CONST_OPORA);
    pCanvas_Polyline(Image1, points, 1);
    Shtrih(points, 7.0, -1.0, 1.0);

    points[0] = Point(point_0.x + 5 , zero_py - CONST_OPORA);
    points[1] = Point(point_0.x + 5 , zero_py + CONST_OPORA);
	pCanvas_Polyline(Image1, points, 1);
    Shtrih(points, 7.0, 1.0, 1.0);
  }
  pCanvas_Ellipse(Image1, point_0.x+3, point_0.y+3, point_0.x-3, point_0.y-3);
}
//-------------------------------------------------------------
// Штриховка
void __fastcall TRackLoadFrame::Shtrih(TPoint *points, float s_s, float mx, float my) {
    // points - точки линии
	// s_s - шаг штриховки
    // mx, my: +1 или -1  - множители, определяющие направление штриховки
    float delx, dely;
	int k;
    TPoint vert[2];
    float l_s;

	delx = points[1].x - points[0].x;
    dely = points[1].y - points[0].y;
    l_s = sqrt(delx*delx + dely*dely);

    for (k=0; k < l_s; k += s_s) {
      vert[0] = Point(points[0].x + delx*k/l_s, points[0].y + dely*k/l_s);
      vert[1] = Point(vert[0].x + mx*s_s, vert[0].y +my*s_s);
      pCanvas_Polygon(Image1, vert, 1);
    }
}
//------------------------------------------------------------------------------------------------------
// Рисование сосредоточенных нагрузок
void __fastcall TRackLoadFrame::Draw_load(double zero_px, double zero_py, int i, float scale, float scale_load) {
  TPoint points[10];
  TPoint vert[10];
  TPoint point_0;
  int X1, X2, X3, X4, Y1, Y2, Y3, Y4;

	pPen_Color(Image1, clMaroon);
    pBrush_Color(Image1, clMaroon);
    pBrush_Style(Image1, bsClear);

    point_0 = Point(zero_px + loads[i].X*scale, zero_py);

    if (loads[i].v!=0) {
	  points[0] = point_0;
      points[1] = Point(point_0.x, point_0.y - loads[i].v*scale_load);
      CoorAx.PutArrow(points, 0, MAX_PIC);
      CoorAx.SetArrow();

      pPen_Width(Image1, 1);;
      pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
	  pCanvas_Polyline(Image1, CoorAx.Ar, 3);
      pFont_Color(Image1, clWhite);
      pCanvas_TextOut(Image1, points[1].x+2, points[1].y, "Py="+FloatToStr(loads[i].v));
      pBrush_Style(Image1, bsSolid);
    }
    if (loads[i].c!=0) {

	  X1 = point_0.x - RadMoment;
      Y1 = point_0.y - RadMoment;
      X2 = point_0.x + RadMoment;
	  Y2 = point_0.y + RadMoment;
      X3 = point_0.x;
      Y3 = point_0.y + RadMoment;
      X4 = point_0.x;
	  Y4 = point_0.y - RadMoment;
      vert[2] = Point(X1, Y1);
      vert[3] = Point(X2, Y2);
      vert[0] = Point(X3, Y3);
      vert[1] = Point(X4, Y4);
      if (loads[i].c < 0) {
        points[0] = Point(X2, Y2 - 5);
        points[1] = Point(X3, Y3);
	  }
	  else {
        points[0] = Point(X2, Y1 + 5);
        points[1] = Point(X4, Y4);
	  }
      CoorAx.PutArrow(points, 0, MAX_PIC);
      CoorAx.SetArrow();

	  pPen_Width(Image1, 1);;
      pCanvas_Arc(Image1, vert, vert + 2);
      pBrush_Style(Image1, bsSolid);
      pCanvas_Ellipse(Image1, point_0.x - 2, point_0.y - 2, point_0.x + 2, point_0.y + 2);
      pBrush_Color(Image1, clMaroon);
      pCanvas_Polygon(Image1, CoorAx.Ar, 3);
	  pCanvas_Ellipse(Image1, point_0.x - 2, point_0.y - 2, point_0.x + 2, point_0.y + 2);
      pFont_Color(Image1, clWhite);
      pBrush_Style(Image1, bsClear);
	  pCanvas_TextOut(Image1, points[1].x + 5, points[1].y + 2, "Mz="+FloatToStr(loads[i].c));
      pBrush_Style(Image1, bsSolid);
    }
}
//----------------------------------------------------------------------------------------------------
// Рисование распределенных нагрузок и упругого основания
void __fastcall TRackLoadFrame::Draw_q_or_kp(AnsiString Name, TColor color, float mult, BeamRegion* Ar, double zero_px, double zero_py, int i, float scale, float scale_load, float step) {
  TPoint points[10];
  TPoint vert[10];
  TPoint point_0;
  TPoint point_1;
  TPoint point_d;
  int k, n;
  float del;

    if (Ar[i].begValue==0 && Ar[i].endValue==0)
	   return;
    pPen_Color(Image1, color);
    pBrush_Style(Image1, bsClear);

    point_0 = Point(zero_px + Ar[i].X0*scale, zero_py);
    point_1 = Point(point_0.x + Ar[i].Len*scale, zero_py);
    n = ceil(Ar[i].Len*scale/step);

    points[0] = point_0;
    points[1] = Point(point_0.x, point_0.y - mult*Ar[i].begValue*scale_load);
	del = (Ar[i].endValue - Ar[i].begValue)*scale_load;
    for (k=0; k <=n ; k++) {

	  vert[0] = Point(point_0.x + k*Ar[i].Len*scale/n, point_0.y);
	  vert[1] = Point(vert[0].x, points[1].y - mult*del*k/n);
	  if (mult == -1) {  // перевернуть
        point_d = vert[0];
        vert[0] = vert[1];
        vert[1] = point_d;
      }
      CoorAx.PutArrow(vert, 0, MAX_PIC);
	  CoorAx.SetArrow();

      pPen_Width(Image1, 1);
      pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
	  pCanvas_Polyline(Image1, CoorAx.Ar, 3);
    }
    if (mult == -1) {
       points[2] = vert[0];
    }
    else
       points[2] = vert[1];
    pCanvas_Polyline(Image1, points+1, 1);
    if (mult == -1) {
      Shtrih(points+1, 10.0, -1.0, 1.0);
    }

	pFont_Color(Image1, clWhite);
    pCanvas_TextOut(Image1, points[1].x+2, points[1].y, Name+FloatToStr(Ar[i].begValue));
	pBrush_Style(Image1, bsSolid);
}
//----------------------------------------------------------------------------------------------------
// Рисование эпюры продольных нагрузок
void __fastcall TRackLoadFrame::Draw_N(TColor colorPen, TColor colorBrush, BeamRegion* Ar, double zero_px, double zero_py, int i, float scale, float scale_load, float step) {
  TPoint vert[10];
  TPoint point_0;
  TPoint point_1;
  int n, k;

    if (Ar[i].begValue==0 && Ar[i].endValue==0)
       return;
    pPen_Color(Image1, colorPen);
    pBrush_Color(Image1, colorBrush);

	point_0 = Point(zero_px + Ar[i].X0*scale, zero_py);
    point_1 = Point(point_0.x + Ar[i].Len*scale, zero_py);

    vert[0] = point_0;
    vert[1] = Point(point_0.x, point_0.y - Ar[i].begValue*scale_load);
    vert[2] = Point(point_0.x + Ar[i].Len*scale, vert[1].y);
	vert[3] = Point(vert[2].x, point_1.y);
    vert[4] = vert[0];
    //pCanvas_Polygon(Image1, vert, 4);
    pCanvas_Polyline(Image1, vert, 4);
    n = ceil(Ar[i].Len*scale/step);
    for (k=1; k<n; k++) {
      vert[2] = Point(point_0.x + k*Ar[i].Len*scale/n, vert[0].y);
	  vert[3] = Point(vert[2].x, vert[1].y);
	  pCanvas_Polyline(Image1, vert+2, 1);
    }

	pBrush_Style(Image1, bsClear);
    pFont_Color(Image1, clWhite);
    pCanvas_TextOut(Image1, vert[1].x+2, vert[1].y, "N="+FloatToStr(Ar[i].begValue));
    pBrush_Style(Image1, bsSolid);
}
//--------------------------------------------------------------------
void __fastcall TRackLoadFrame::BitBtn_InsertClick(TObject *Sender)
{
	int rc;
	// Прочитать данные из табицы и сформировать регионы
	rc = LoadDataFromGrid_param();
	if (rc>0) return;

	//Draw_beam();
}
//---------------------------------------------------------------------------

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

void __fastcall TRackLoadFrame::ListBox1Click(TObject *Sender)
{
	 int i,j;

	 for (i=0, j=0; i<7; i++) {
		 if (ListBox1->Selected[i]==true) {
		   index_fun[j] = i;
		   //if (i>0)
		   //	 index_fun[j] = i - 1;
		   //else
		   //	 index_fun[j] = 4;
		   j++;
         }
	 }
	 n_fun = j;
     if (n_fun > 0) {
		DrawOut(n_fun, n_result, index_fun);
	 }

}
//---------------------------------------------------------------------------


void __fastcall TRackLoadFrame::BitBtnOutEMFClick(TObject *Sender)
{
      char *ch;
	  char str[240];
      int  i,rc;
      FILE *fp;

      strcpy(str,Data->Variant.c_str());
      for (i=strlen(str)-1; i>=0; i--)
         if (str[i]=='\\') break;
      ch=strchr(str+i+1,(int)'.');
      if (ch==NULL) ch=str+i+1;
      for (i=0; i<100; i++) {
        sprintf(ch,"%.2d.emf",i);
        fp=fopen(str,"rb");
        if (fp==NULL)
		  break;
		fclose(fp);
	  }
      Chart1->SaveToMetafileEnh(str);

}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::BitBtn_ReplaceClick(TObject *Sender)
{
   double x00;
   int i, rc;
   double Len;

   if (SelectRow<=0) {
	   rc = ApplicationMessageBox("Не выбрана строка таблицы",
                          " ", MB_OK | MB_ICONERROR);
        return;
   }

   if (!BitBtn_Add->Enabled) {
	   // Обновить собственный вес
	   Edit_n1->Text = FloatToStrF(-1*FRo_beam*9.81*1e-3,ffFixed, 8, 3);
	   Edit_n2->Text = FloatToStrF(-1*FRo_beam*9.81*1e-3,ffFixed, 8, 3);
       InsertToGridFromText(SelectRow);
   // Прочитать данные из таблицы и сформировать регионы
	   rc = LoadDataFromGrid_param();
	   if (rc>0) return;

   }
   else {
   // Вставить текст в строку таблицы
	 InsertToGridFromText(SelectRow);
   // Прочитать данные из таблицы и сформировать регионы
	 rc = LoadDataFromGrid_param();
	 if (rc>0) return;
   }

	//Draw_beam();
}
//---------------------------------------------------------------------------
 /*-------------------------------------------------------------------*/
 /*  Функция сравнения массивов         */
 /*  сравнение заканчивается, когда последние элементы =0;            */
 /*  Возвращаемое значение :                                          */
 /*         -1   -первый элемент "меньше" второго;                    */
 /*          0   -элементы "равны";                                   */
 /*          1   -первый элемент "больше" второго.                    */
 /*-------------------------------------------------------------------*/
int   cmp_Load(Load *elem1, Load *elem2)
{
	   if ( elem1->X > elem2->X)
		  return 1;
	   if ( elem1->X < elem2->X)
          return -1;
	   else
          return 0;
}
 /*-------------------------------------------------------------------*/
 /*  Функция сравнения массивов         */
 /*  сравнение заканчивается, когда последние элементы =0;            */
 /*  Возвращаемое значение :                                          */
 /*         -1   -первый элемент "меньше" второго;                    */
 /*          0   -элементы "равны";                                   */
 /*          1   -первый элемент "больше" второго.                    */
 /*-------------------------------------------------------------------*/
int   cmp_Constraint(Constraint *elem1, Constraint *elem2)
{
       if ( elem1->X > elem2->X)
          return 1;
	   if ( elem1->X < elem2->X)
		  return -1;
	   else
		  return 0;
}

void __fastcall TRackLoadFrame::Edit_n1Change(TObject *Sender)
{
   if (!CheckBox_Linear_n->Checked) {
	  Edit_n2->Text = Edit_n1->Text;
   }

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::CheckBox_Linear_nClick(TObject *Sender)
{
	if (CheckBox_Linear_n->Checked) {
	  Label_n2->Visible = true;
	  Edit_n2->Visible = true;
	}
	else {
	  Label_n2->Visible = false;
	  Edit_n2->Visible = false;
	  Edit_n2->Text = Edit_n1->Text;
	}

}

//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::CheckBox_TyClick(TObject *Sender)
{
   if (!flag_constr) {
   }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::PageControl_BoundCondChange(TObject *Sender)
{
	if (PageControl_BoundCond->ActivePage==TabSheet_Constr_Raskrep) {
	   type_region = typeConstraint;
	   //------------------------------------------------------------
	   // Сменить регион
	   ChangeRegion(type_region, Sender);
	}
	if (PageControl_BoundCond->ActivePage==TabSheet_Load0) {
	   //-----------------------------------------------------------------
	   PageControl_LoadChange(Sender);     // здесь устанавливается регион и вызывается  ChangeRegion
	}
	if (PageControl_BoundCond->ActivePage==TabSheet_Combin) {
	   int i, j;
	   AnsiString ind;
	   StringGrid_Combin->ColCount = n_beam + 1;
	   StringGrid_Combin->RowCount = 1;
	   StringGrid_Combin->Cells[0][0] = "№ комб.";
	   for (i=1; i<StringGrid_Combin->ColCount; i++) {
		  if (type_zagr[i-1]==zagrCONSTANT)
			ind = " C";
		  if (type_zagr[i-1]==zagrTEMPORAR)
			ind = " L";
		  if (type_zagr[i-1]==zagrTRANSIST)
			ind = " S";
		  StringGrid_Combin->Cells[i][0] = IntToStr(i) + ind;
	   }
	   if (flag_comb) {
		 StringGrid_Combin->RowCount = n_comb + 1;
		 for (i=1; i<StringGrid_Combin->RowCount; i++) {
			 StringGrid_Combin->Cells[0][i] = IntToStr(i);
			 for (j=1; j<StringGrid_Combin->ColCount; j++)
			   StringGrid_Combin->Cells[j][i] = FloatToStr(Combin_zagr[i-1][j-1]);
		 }
	   }

	}

}
//---------------------------------------------------------------------------



void __fastcall TRackLoadFrame::SpeedButtonFix_FixClick(TObject *Sender)
{
   if (SpeedButtonFix_Fix->Down) {
	 StringGrid_Constr->RowCount = 1;

	 Edit_X0Constr->Text = "0";
	 CheckBox_Tx->Checked = true;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = true;
	 BitBtn_AddClick(Sender);

	 Edit_X0Constr->Text = FloatToStr(Length_rack);
	 CheckBox_Tx->Checked = false;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = true;
	 BitBtn_AddClick(Sender);
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XZ[0] = 0.5;
	   StringGrid_koeff->Cells[2][1] = Koeff_length_XZ[0];
	 }
   }
   flag_constr = false;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButtonPin_PinClick(TObject *Sender)
{
   if (SpeedButtonPin_Pin->Down) {
	 StringGrid_Constr->RowCount = 1;

	 Edit_X0Constr->Text = "0";
	 CheckBox_Tx->Checked = true;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = false;
	 BitBtn_AddClick(Sender);

	 Edit_X0Constr->Text = FloatToStr(Length_rack);
	 CheckBox_Tx->Checked = false;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = false;
	 BitBtn_AddClick(Sender);
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XZ[0] = 1.0;
	   StringGrid_koeff->Cells[2][1] = Koeff_length_XZ[0];
	 }
   }
   flag_constr = false;
}//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::PageControl_LoadChange(TObject *Sender)
{

	if (PageControl_Load->ActivePage==TabSheet_ConcentrLoad) {
	  type_region = typeConcentrLoad;
	}
	if (PageControl_Load->ActivePage==TabSheet_LinearLoad) {
	  type_region = typeLinearLoad;
	}
	if (PageControl_Load->ActivePage==TabSheet_DistrN) {
	  type_region = typeDistrN;
	}
	//-----------------------------------------------------------------------
	// Сменить регион
	ChangeRegion(type_region, Sender);
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::ChangeRegion(int type_region, TObject *Sender)
{
   int i;
   double pos;

	 TabSheet_N_Loads->TabVisible = false;
	 TabSheet_LinLoads->TabVisible = false;
	 TabSheet_ConcLoads->TabVisible = false;
	 TabSheet_Constraints->TabVisible = false;

	 switch (type_region) {
	 case typeLinearLoad:
	   Arbit = q_;
	   A_length = &beam_mod.q_length;
	   TabSheet_LinLoads->TabVisible = true;
	 break;
	 case typeDistrN:
	   Arbit = N_;
	   A_length = &beam_mod.N_length;
	   TabSheet_N_Loads->TabVisible = true;
	 break;
	 case typeConcentrLoad:
	   A_length = &beam_mod.loads_length;
	   TabSheet_ConcLoads->TabVisible = true;
	 break;
	 case typeConstraint:
	   A_length = &beam_mod.constr_length;
	   TabSheet_Constraints->TabVisible = true;

	   CSpinEdit_EtaghChange(Sender);
	   StringGrid_Constr->RowCount = 1;
	   StringGrid_koeff->RowCount = MAX(2, N_part + 1);
	   CSpinEdit_Etagh->Value = N_part;

	   pos = 0;
	   for (i=0; i<N_part; i++) {
		  pos += Length_part[i];
		  StringGrid_koeff->Cells[0][i+1] = i+1;
		  StringGrid_koeff->Cells[1][i+1] = pos;
		  StringGrid_koeff->Cells[2][i+1] = Koeff_length_XZ[i];
		  StringGrid_koeff->Cells[3][i+1] = Koeff_length_XY[i];
	   }

	   for (i=0; i<beam_mod.constr_length; i++) {
		   ConstraintToGrid_param(constr[i], -1);
	   }
	 break;
	 }
	 //Draw_beam();

}
//--------------------------------------------------------------------------
//
void __fastcall TRackLoadFrame::ComboBox_num_zagrChange(TObject *Sender)
{
	 int i;
	 //-------------------------------------------------------------------
	 PageControl_BoundCondChange(Sender);

	 int k = ComboBox_num_zagr->ItemIndex;

	 if (beam_mod.EI_length != 0 && Length_rack > 0) {           //beam_mod.loads_length  beam_mod.q_length
		// Поместить регион в депозитарий
		 Put_beam_data();
	 }

	 if (n_beam == MAX_BEAM_DATA) {
	   int i = Application->MessageBox(L"Количество загружений достигло предельного количества.", L" ",
		  MB_OK | MB_ICONERROR);
	   return;
	 }
	 Edit_X0Load->Text = 0;
	 Edit_Fz->Text = 0;
	 Edit_Fx->Text = 0;
	 Edit_My->Text = 0;
	 Edit_excentr_Load->Text = 0;
	 StringGrid_Loads->RowCount = 1;

	 Edit_x0->Text = 0;
	 Edit_Len->Text = 0;
	 Edit_p1->Text = 0;
	 Edit_p2->Text = 0;
	 StringGrid_q->RowCount = 1;

	 Edit_x0n->Text = 0;
	 Edit_Len_n->Text = 0;
	 Edit_n1->Text = 0;
	 Edit_n2->Text = 0;
	 Edit_excentr_N->Text = 0;
	 StringGrid_N->RowCount = 1;


	 // Взять регионы из депозитария
	 int rc = Get_beam_data(k);     //q_v[0]
	 if (rc>0)
		return;

	 type_region = -1;
	 for (i=0; i<beam_mod.N_length; i++) {
			StringGrid_N->Cells[0][i+1]= IntToStr(i+1);
			StringGrid_N->Cells[1][i+1]= FloatToStr(N_[i].X0);
			StringGrid_N->Cells[2][i+1]= FloatToStr(N_[i].X0 + N_[i].Len);
			StringGrid_N->Cells[3][i+1]= FloatToStr(N_[i].begValue);
			StringGrid_N->Cells[4][i+1]= FloatToStr(N_[i].endValue);
			StringGrid_N->Cells[5][i+1]= FloatToStr(dist_eN[i]);
	 }
	 StringGrid_N->RowCount = beam_mod.N_length+1;
	 for (i=0; i<beam_mod.loads_length; i++) {
			StringGrid_Loads->Cells[0][i+1]= IntToStr(i+1);
			StringGrid_Loads->Cells[1][i+1]= FloatToStr(loads[i].X);
			StringGrid_Loads->Cells[2][i+1]= FloatToStr(loads[i].v);
			StringGrid_Loads->Cells[3][i+1]= FloatToStr(loads[i].u);
			StringGrid_Loads->Cells[4][i+1]= FloatToStr(loads[i].c);
			StringGrid_Loads->Cells[5][i+1]= FloatToStr(dist_eL[i]);
	 }
	 StringGrid_Loads->RowCount = beam_mod.loads_length+1;
	 for (i=0; i<beam_mod.q_length; i++) {
			StringGrid_q->Cells[0][i+1]= IntToStr(i+1);
			StringGrid_q->Cells[1][i+1]= FloatToStr(q_[i].X0);
			StringGrid_q->Cells[2][i+1]= FloatToStr(q_[i].X0 + q_[i].Len);
			StringGrid_q->Cells[3][i+1]= FloatToStr(q_[i].begValue);
			StringGrid_q->Cells[4][i+1]= FloatToStr(q_[i].endValue);
	 }
	 StringGrid_q->RowCount= beam_mod.q_length+1;
	 TabSheet_Constraints->TabVisible = false;
	 PageControl_BoundCond->ActivePage = TabSheet_Load0;
	 if (beam_mod.N_length!=0) {
		 PageControl_Load->ActivePage = TabSheet_DistrN;
		 PageControl_TabLoads->ActivePage = TabSheet_N_Loads;
		 TabSheet_N_Loads->TabVisible = true;
		 TabSheet_ConcLoads->TabVisible = false;
		 TabSheet_LinLoads->TabVisible = false;
		 type_region = typeDistrN;
	 }
	 if (beam_mod.loads_length!=0) {
		 PageControl_Load->ActivePage = TabSheet_ConcentrLoad;
		 PageControl_TabLoads->ActivePage = TabSheet_ConcLoads;
		 TabSheet_N_Loads->TabVisible = false;
		 TabSheet_ConcLoads->TabVisible = true;
		 TabSheet_LinLoads->TabVisible = false;
		 type_region = typeConcentrLoad;
	 }
	 if (beam_mod.q_length!=0) {
		 PageControl_Load->ActivePage = TabSheet_LinearLoad;
		 PageControl_TabLoads->ActivePage = TabSheet_LinLoads;
		 TabSheet_N_Loads->TabVisible = false;
		 TabSheet_ConcLoads->TabVisible = false;
		 TabSheet_LinLoads->TabVisible = true;
		 type_region = typeLinearLoad;
	 }
     // Конфигурация панели в зависимости от того Вес или произвольная нагрузка
	 ConfigPageControl_Load(k, Sender);

	 k_beam = ComboBox_num_zagr->ItemIndex;
}
//---------------------------------------------------------------------------
// Конфигурация панели в зависимости от того Вес или произвольная нагрузка
void __fastcall TRackLoadFrame::ConfigPageControl_Load(int k, TObject *Sender) {
	 if (!flag_weight[k]) {
	   TabSheet_ConcentrLoad->TabVisible = true;
	   TabSheet_LinearLoad->TabVisible = true;
	   TabSheet_DistrN->TabVisible = true;
	   Label_Weight->Visible = false;
	   ComboBox_type_zagr->Enabled = true;
	   PageControl_Load->Enabled = true;
	   Edit_gamma_f->ReadOnly = false;
	   Edit_koef_low->ReadOnly = false;
	   ComboBox_type_zagr->Enabled = true;
	   SpeedButtonTabl->Enabled = true;
	   BitBtn_Add->Enabled = true;
	   BitBtn_Replace->Enabled = true;
	   BitBtnDelete->Enabled = true;
	 }
	 else {
	   TabSheet_ConcentrLoad->TabVisible = false;
	   TabSheet_DistrN->TabVisible = true;
	   TabSheet_LinearLoad->TabVisible = false;
	   PageControl_Load->ActivePage = TabSheet_DistrN;
	   Label_Weight->Visible = true;

	   CheckBox_Linear_n->Checked = false;
	   PageControl_Load->Enabled = false;
	   Edit_gamma_f->ReadOnly = true;
	   Edit_koef_low->ReadOnly = true;
	   ComboBox_type_zagr->Enabled = false;
	   SpeedButtonTabl->Enabled = false;
	   BitBtn_Add->Enabled = false;
	   //BitBtn_Replace->Enabled = false;
	   BitBtnDelete->Enabled = false;
	 }
 }
// Удалить загружение
void __fastcall TRackLoadFrame::SpeedButtonDeleteClick(TObject *Sender)
{
  int i, rc;
	 if (flag_comb) {
		 #ifdef EMBRAC
		  rc=Application->MessageBox(L"При удалении загружений существующие сочетания будут также удалены. Продолжить выолнение?", L"",
								  MB_YESNO | MB_ICONQUESTION);
		 #else
		  rc=Application->MessageBox("При удалении загружений существующие сочетания будут также удалены. Продолжить выолнение?", "",
								  MB_YESNO | MB_ICONQUESTION);
		 #endif
		 if (rc==IDNO) return;
		 else
		   flag_comb = false;
	 }
  int k = ComboBox_num_zagr->ItemIndex;
	 #ifdef EMBRAC
	 i=Application->MessageBox((L"Удалить загружение №"+IntToStr(k+1)+"?").c_str(), L"",
								  MB_YESNO | MB_ICONQUESTION);
	 #else
	 i=Application->MessageBox(("Удалить загружение №"+IntToStr(k+1)+"?").c_str(), "",
								  MB_YESNO | MB_ICONQUESTION);
	 #endif
  if (i==IDNO) return;

  // Длины в депозитарии текущего загружения
  int lenEI;
  int lenq_;
  int lenN_;
  int lenld;

  // Адрес в депозитарии текущего загружения
  int iEI;
  int iq_;
  int iN_;
  int ild;

  if (k==0) {
   iEI = 0;
   iq_ = 0;
   iN_ = 0;
   ild = 0;
   lenEI = index_beam[k][0];
   lenq_ = index_beam[k][1];
   lenN_ = index_beam[k][4];
   lenld = index_beam[k][5];
  }
  else {
   iEI = index_beam[k-1][0];
   iq_ = index_beam[k-1][1];
   iN_ = index_beam[k-1][4];
   ild = index_beam[k-1][5];
   lenEI = index_beam[k][0] - iEI;
   lenq_ = index_beam[k][1] - iq_;
   lenN_ = index_beam[k][4] - iN_;
   lenld = index_beam[k][5] - ild;
  }
  for (i=k; i<n_beam-1; i++) {
	type_zagr[i] = 	type_zagr[i+1];  // тип загружения
	flag_weight[i] = flag_weight[i+1];
	Koeff_gamma_f[i] = Koeff_gamma_f[i+1];  // Коэффициенты надежности
	Koeff_low[i] = Koeff_low[i+1];  // Понижающий коэффициент
	index_beam[i][0] = index_beam[i+1][0] - lenEI;
	index_beam[i][1] = index_beam[i+1][1] - lenq_;
	index_beam[i][4] = index_beam[i+1][4] - lenN_;
	index_beam[i][5] = index_beam[i+1][5] - lenld;
  }
  memcpy(EI_v+iEI, EI_v + iEI + lenEI, sizeof(BeamRegion)*(index_portion - (iEI + lenEI)));        //EI[0]
  memcpy(q_v+iq_, q_v + iq_ + lenq_, sizeof(BeamRegion)*(index_portion - (iq_ + lenq_)));
  memcpy(N_v+iN_, N_v + iN_ + lenN_, sizeof(BeamRegion)*(index_portion - (iN_ + lenN_)));
  memcpy(dist_eNv+iN_, dist_eNv + iN_ + lenN_, sizeof(double)*(index_portion - (iN_ + lenN_)));
  memcpy(loads_v+ild, loads_v + ild + lenld, sizeof(Load)*(index_portion - (ild + lenld)));
  memcpy(dist_eLv+ild, dist_eLv + ild + lenld, sizeof(double)*(index_portion - (ild + lenld)));
   //------------------------------------------------------------
   int n_row = ComboBox_num_zagr->Items->Count;
   n_row--;
   // Взять регионы из депозитария
   if (n_row>0) {
	 int rc = Get_beam_data(0);
	 if (rc>0)
	   return;
   }
   else {
	 StringGrid_q->RowCount = 1;
	 StringGrid_N->RowCount = 1;
	 StringGrid_Loads->RowCount = 1;
	 beam_mod.q_length = 0;
	 beam_mod.N_length = 0;
	 beam_mod.loads_length = 0;
   }
   ComboBox_num_zagr->ItemIndex = 0;

   if (n_row > 1)
		TabSheet_Combin->TabVisible = true;
   else
		TabSheet_Combin->TabVisible = false;
   ComboBox_num_zagr->Items->Clear();
   for (i=0; i<(MAX(1, n_row)); i++) {
	   ComboBox_num_zagr->Items->Add(IntToStr(i+1));
   }
   ComboBox_num_zagr->ItemIndex = 0;
   k_beam = 0;
   n_beam--;
   if (n_beam==0) {
	 Label_Weight->Visible = false;
	 ComboBox_type_zagr->ItemIndex = 0;
	 ComboBox_type_zagrChange(Sender);
   }
   ComboBox_num_zagrChange(Sender);
   Edit_num_zagr->Text = IntToStr(n_beam);

}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::ComboBox_type_zagrChange(TObject *Sender)
{
   TabSheet_ConcentrLoad->TabVisible = true;
   TabSheet_DistrN->TabVisible = true;
   switch (ComboBox_type_zagr->ItemIndex) {
   case 0:
	 Edit_gamma_f->Text =  1.1;
   break;
   case 1:
	 Edit_gamma_f->Text =  1.1;
   break;
   case 2:
	 Edit_gamma_f->Text =  1.1;
   break;
   }
   // Установить тип загружения
   Set_type_zagr(k_beam);
}
//-----------------------------------------------------------------------------
// Установить тип загружения num
void __fastcall TRackLoadFrame::Set_type_zagr(int num)
{
   switch (ComboBox_type_zagr->ItemIndex) {
   case 0:
	 type_zagr[num] = zagrCONSTANT;
   break;
   case 1:
	 type_zagr[num] = zagrTEMPORAR;
   break;
   case 2:
	 type_zagr[num] = zagrTRANSIST;
   break;
   }
   if (Label_Weight->Visible)
	  flag_weight[num] = true;
   else
	  flag_weight[num] = false;
}
//---------------------------------------------------------------------------
// Заполнить таблицу комбинаций
void __fastcall TRackLoadFrame::PutZagrToDepo()
{
	 int rc;

	 //----------------------------------------------------------------
	 // записать текущее загружение в депозитарий
	 Put_beam_data();
	 // Установить тип загружения
	 Set_type_zagr(k_beam);
	 // Установить коэфф. надежности
	 rc = String_double_plus(Label_gamma_f->Caption, Edit_gamma_f->Text, &(Koeff_gamma_f[k_beam]));
	 if (rc>0) return;
	 // Установить понижающий коэфф.
	 rc = String_double_plus(Label_koef_low->Caption, Edit_koef_low->Text, &(Koeff_low[k_beam]));
	 if (rc>0) return;
	 //-----------------------------------------------------------------

}
//---------------------------------------------------------------------
// Отобразить редактируемую таблицу
void __fastcall TRackLoadFrame::SpeedButtonTablClick(TObject *Sender)
{
	 int length_q;
	 BeamRegion *Aq;
	 int length_N;
	 BeamRegion *AN;
	 int length_loads;
	 Load *Aloads;
	 int length_constr;
	 Constraint *Aconstr;
	 int k_zagr;
	 int *index;
	 double *exc_N;
	 double *exc_L;

	 GetRegion(&k_zagr, &length_q, &Aq, &length_N, &AN,
			   &length_loads, &Aloads, &length_constr, &Aconstr, &exc_N, &exc_L);

	 TablZagrForm->Koeff_gamma_f = Koeff_gamma_f[k_beam];
	 TablZagrForm->Koeff_low = Koeff_low[k_beam];
	 TablZagrForm->PutLoadRegion(Length_rack, k_beam, type_zagr, length_q, Aq, length_N, AN, length_loads, Aloads, Sender);

	 TablZagrForm->ShowModal();

	 beam_mod.q_length = TablZagrForm->length_q0;
	 beam_mod.N_length = TablZagrForm->length_N0;
	 beam_mod.loads_length = TablZagrForm->length_loads0;
	 Koeff_gamma_f[k_beam] = TablZagrForm->Koeff_gamma_f;
	 Koeff_low[k_beam] = TablZagrForm->Koeff_low;
	 Edit_gamma_f->Text = FloatToStr(Koeff_gamma_f[k_beam]);
	 Edit_koef_low->Text = FloatToStr(Koeff_low[k_beam]);


	// Поместить регион в депозитарий
	 Put_beam_data();
	 //--------------------------------------------------------------------------
	 // Загрузка данных из массива в таблицы нагрузок
	 StringGrid_Loads->RowCount = 1;
	 StringGrid_q->RowCount = 1;
	 StringGrid_N->RowCount = 1;
	 LoadDataToGrid_param(typeLinearLoad);
	 LoadDataToGrid_param(typeDistrN);
	 LoadDataToGrid_param(typeConcentrLoad);
	 if (StringGrid_N->RowCount > 1) {
	   type_region = typeDistrN;
	   SelectRow = 1;
	 // Поместить данные строки таблицы в поля
	   int rc = LoadDataFromGrid_ToText();
	 }
	 if (StringGrid_Loads->RowCount > 1) {
	   type_region = typeConcentrLoad;
	   SelectRow = 1;
	 // Поместить данные строки таблицы в поля
	   int rc = LoadDataFromGrid_ToText();
	 }
	 if (StringGrid_q->RowCount > 1) {
	   type_region = typeLinearLoad;
	   SelectRow = 1;
	 // Поместить данные строки таблицы в поля
	   int rc = LoadDataFromGrid_ToText();
	 }
	 type_zagr[k_beam] = TablZagrForm->type_zagr0;  // тип загружения
	 ComboBox_type_zagr->ItemIndex = type_zagr[k_beam];

}
//---------------------------------------------------------------------------
// Принять длину
void __fastcall TRackLoadFrame::SpeedButton_ApplyClick(TObject *Sender)
{
   int rc;
   if (n_beam>0 || beam_mod.q_length>0 || beam_mod.N_length>0 || beam_mod.loads_length>0 || beam_mod.constr_length>0) {
	 #ifdef EMBRAC
	 rc=Application->MessageBox(L"При изменении длины стойки все загружения и опоры будут удалены. Продолжить выолнение?", L"",
								  MB_YESNO | MB_ICONQUESTION);
	 #else
	 rc=Application->MessageBox("При изменении длины стойки все загружения и опоры будут удалены. Продолжить выолнение?", "",
								  MB_YESNO | MB_ICONQUESTION);
	 #endif
	 if (rc==IDNO) return;

   }
   rc = String_double_range(Label_Length->Caption, Edit_Length->Text, 0.1, 100.0, &Length_rack);
   if (rc>0) {
	 Length_rack = 0;
	 return;
   }
   Length_part[0] = Length_rack;

   if (Length_rack != EI[0].Len) {
	  // Удалить все загружения
	  DeleteZagr(Sender);
   }
   EI[0].begValue = IE_beam;
   EI[0].endValue = IE_beam;

   //EI[0].begValue = 1e9;
   //EI[0].endValue = 1e9;

   EI[0].X0 = 0;
   EI[0].Len = Length_rack;
   beam_mod.EI_length = 1;
   ImageList1->GetBitmap(0, SpeedButton_Apply->Glyph);
   //Draw_beam();

   PageControl_BoundCond->Visible = true;
   PageControl_TabLoads->Visible = true;

   //--------------------------------------------------------------
   // Создание загружения Собственный вес
   //NewBalka(Sender);
   //
   PageControl_Load->ActivePage = TabSheet_DistrN;
   PageControl_LoadChange(Sender);
   Edit_x0n->Text = "0";
   Edit_Len_n->Text = Edit_Length->Text;
   Edit_n1->Text = FloatToStrF(-1*FRo_beam*9.81*1e-3,ffFixed, 8, 3);
   Edit_n2->Text = FloatToStrF(-1*FRo_beam*9.81*1e-3,ffFixed, 8, 3);
   CheckBox_Linear_n->Checked = false;
   BitBtn_AddClick(Sender);
   PageControl_Load->Enabled = false;
   Label_Weight->Visible = true;
   Edit_gamma_f->ReadOnly = true;
   Edit_koef_low->ReadOnly = true;
   ComboBox_type_zagr->Enabled = false;
   SpeedButtonTabl->Enabled = false;
   BitBtn_Add->Enabled = false;
   //BitBtn_Replace->Enabled = false;
   BitBtnDelete->Enabled = false;
   ComboBox_type_zagr->ItemIndex = 0;
   ComboBox_type_zagrChange(Sender);
   Edit_gamma_f->Text = "1.05";
   Edit_koef_low->Text = "1";
   type_zagr[0] = ComboBox_type_zagr->ItemIndex;  // тип загружения
   Koeff_gamma_f[0] = 1.05;  // Коэффициенты надежности
   Koeff_low[0] = 1.0;  // Понижающий коэффициент
   k_beam = 0;
   index_raskr = 0;
   Edit_num_zagr->Text = "1";
   StringGrid_koeff->Cells[0][1] = 1;
   StringGrid_koeff->Cells[1][1] = Length_rack;
   StringGrid_koeff->Cells[2][1] = "";
   StringGrid_koeff->Cells[3][1] = "";

   ConfigPageControl_Load(0, Sender);

}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::SpeedButton_AddClick(TObject *Sender)
{
	 int rc;
	 if (flag_comb) {
		 #ifdef EMBRAC
		  rc=Application->MessageBox(L"При добавлении загружений существующие сочетания будут удалены. Продолжить выолнение?", L"",
								  MB_YESNO | MB_ICONQUESTION);
		 #else
		  rc=Application->MessageBox("При добавлении загружений существующие сочетания будут удалены. Продолжить выолнение?", "",
								  MB_YESNO | MB_ICONQUESTION);
		 #endif
		 if (rc==IDNO) return;
		 else {
		   flag_comb = false;
		   TabSheet_Combin->TabVisible = false;
		   ImageList1->GetBitmap(1, SpeedButton_CallCombin->Glyph);
		   SpeedButton_CallCombin->Glyph->Width = 0;
		   //SpeedButton_CallCombin->Tag = 1 - SpeedButton_CallCombin->Tag;

		 }
	 }
     // задание параметров нового загружения
	 ZagrPlusForm->ShowModal();

	 if (ZagrPlusForm->type_zagr>=0) {
	   // Проверка, нет ли уже загружений типа собственного веса
	   if (ZagrPlusForm->flag_weight) {
		 for (int i=0; i<n_beam; i++) {
		   if (flag_weight[i]) {
			 rc=Application->MessageBox(("В списке загружений уже есть загружение \"Собственный вес\" (№ "+IntToStr(i+1)+")").c_str(), L"",
									 MB_ICONERROR);
			 return;
		   }
		 }
	   }
	   // новое загружение
	   NewBalka(Sender);

	   if (ZagrPlusForm->flag_weight) {
		 //TabSheet_ConcentrLoad->TabVisible = false;
		 //TabSheet_DistrN->TabVisible = false;
	 // Здесь читаются данные из таблицы StringGrid_param в регионы установленного типа
	 // и заполняются таблицы StringGrid_param из регионов нового типа
		 PageControl_Load->ActivePage = TabSheet_LinearLoad;
		 PageControl_LoadChange(Sender);
		 Edit_x0->Text = "0";
		 Edit_Len->Text = Edit_Length->Text;
		 Edit_p1->Text = FloatToStrF(FRo_beam*9.81*1e-3,ffFixed, 8, 3);
		 Edit_p2->Text = FloatToStrF(FRo_beam*9.81*1e-3,ffFixed, 8, 3);
		 CheckBox_Linear->Checked = false;
		 BitBtn_AddClick(Sender);
		 PageControl_Load->Enabled = false;
		 Label_Weight->Visible = true;
		 Edit_gamma_f->ReadOnly = true;
		 Edit_koef_low->ReadOnly = true;
		 ComboBox_type_zagr->Enabled = false;
		 SpeedButtonTabl->Enabled = false;
		 BitBtn_Add->Enabled = false;
		 BitBtn_Replace->Enabled = false;
		 BitBtnDelete->Enabled = false;
	   }
	   else {
		 Label_Weight->Visible = false;
		 TabSheet_ConcentrLoad->TabVisible = true;
		 TabSheet_DistrN->TabVisible = true;
		 TabSheet_LinearLoad->TabVisible = true;
		 ComboBox_type_zagr->Enabled = true;
		 PageControl_Load->Enabled = true;
		 Edit_gamma_f->ReadOnly = false;
		 Edit_koef_low->ReadOnly = false;
		 ComboBox_type_zagr->Enabled = true;
		 SpeedButtonTabl->Enabled = true;
		 BitBtn_Add->Enabled = true;
		 BitBtn_Replace->Enabled = true;
		 BitBtnDelete->Enabled = true;
		 Label_Weight->Visible = false;
	   }
	   ComboBox_type_zagr->ItemIndex = ZagrPlusForm->type_zagr;
	   ComboBox_type_zagrChange(Sender);
	   Edit_gamma_f->Text = FloatToStr(ZagrPlusForm->koeff_gamma_f);
	   Edit_koef_low->Text = FloatToStr(ZagrPlusForm->koeff_low);
	   type_zagr[k_beam] = ComboBox_type_zagr->ItemIndex;  // тип загружения
	   Koeff_gamma_f[k_beam] = ZagrPlusForm->koeff_gamma_f;  // Коэффициенты надежности
	   Koeff_low[k_beam] = ZagrPlusForm->koeff_low;  // Понижающий коэффициент
	   Edit_num_zagr->Text = IntToStr(k_beam+1);
	 }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::ComboBox_num_zagr_rezChange(TObject *Sender)
{
   int i, j, k, m, rc;
   float X;
   float **matr_combin;
   double q_down;
   double q_down_LR;
   double M_down_LR;

   if (ComboBox_num_zagr_rez->ItemIndex < n_beam) {
	 if (ComboBox_num_zagr->ItemIndex != ComboBox_num_zagr_rez->ItemIndex) {
	   ComboBox_num_zagr->ItemIndex = ComboBox_num_zagr_rez->ItemIndex;
	   ComboBox_num_zagrChange(Sender);
	 }
	 //---------------------------------------------------------------------------
	 // Выполнить расчет загружения
	 CalculateExecute(k_beam, false, &q_down, &q_down_LR, &M_down_LR, Sender);

	 // Здесь вызывается DrawOut
	 ListBox1Click(Sender);

   }
   else {
	 m = ComboBox_num_zagr_rez->ItemIndex - n_beam;  // номер сочетания
	 matr_combin = (float**)almat_f(k_result, 7, &rc);
	 if (rc>0) {
	   rc = Application->MessageBox(L"Error almat_f", L" ", MB_OK | MB_ICONERROR);
	   return;
	 }
	 for (i=0; i<k_result; i++) {
	   for (j=0; j<7; j++)
		  matr_combin[i][j] = 0;
	 }
	 for (k=0; k<n_beam; k++) {
		// Взять регионы из депозитария
		int rc = Get_beam_data(k);
		if (rc>0)
		   return;
		//---------------------------------------------------------------------------
		// Выполнить расчет загружения
		CalculateExecute(k_beam, false, &q_down,  &q_down_LR,  &M_down_LR, Sender);

		for (i=0; i<k_result; i++) {
		  for (j=0; j<7; j++) {
			matr_combin[i][j] += matr_result[i][j]*Koeff_gamma_f[k]*Combin_zagr[m][k];
		  }
		}
	 }

	 for (i=0; i<k_result; i++) {
		for (j=0; j<7; j++) {
		  matr_result[i][j] = matr_combin[i][j];
		}
	 }
	 for (i=0; i<k_result; i++) {
	   X = x_result[i];
	   for (j=1; j<7; j++) {
		 if (Max_Value[j] < matr_result[i][j]) {
		   Max_Value[j] = matr_result[i][j];
		   Max_X[j] = X;
		 }
		 if (Min_Value[j] > matr_result[i][j]) {
		   Min_Value[j] = matr_result[i][j];
		   Min_X[j] = X;
		 }
	   }
	 }
	 Max_Value[0] = Round(Max_Value[0], 0);
	 Min_Value[0] = Round(Min_Value[0], 0);

	 Max_Value[1] = Round(Max_Value[1], 0);
	 Min_Value[1] = Round(Min_Value[1], 0);

	 Max_Value[2] = Round(Max_Value[2], 0);
	 Min_Value[2] = Round(Min_Value[2], 0);

	 Max_Value[3] = Round(Max_Value[3], 2);
	 Min_Value[3] = Round(Min_Value[3], 2);

	 Max_Value[4] = Round(Max_Value[4], 1);
	 Min_Value[4] = Round(Min_Value[4], 1);

	 Max_Value[5] = Round(Max_Value[5], 1);
	 Min_Value[5] = Round(Min_Value[5], 1);

	 Max_Value[6] = Round(Max_Value[6], 1);
	 Min_Value[6] = Round(Min_Value[6], 1);

	 // Здесь вызывается DrawOut
	 ListBox1Click(Sender);
	 FREEMAT_(matr_combin);
   }
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::DeleteZagr(TObject *Sender)
{
	  n_beam = 0;

	  Edit_num_zagr->Text = "0";
	  DeleteSupp(Sender);
	  DeleteLoad(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::DeleteSupp(TObject *Sender)
{
	  Edit_X0Constr->Text = 0;
	  CheckBox_Tx->Checked = false;
	  CheckBox_Tz->Checked = false;
	  CheckBox_Ry->Checked = false;
	  beam_mod.constr_length = 0;

	  StringGrid_Constr->RowCount = 1;
}
//---------------------------------------------------------------------------
void __fastcall TRackLoadFrame::DeleteLoad(TObject *Sender)
{
	  beam_mod.q_length=0;
	  beam_mod.N_length=0;
	  beam_mod.loads_length=0;
	  StringGrid_Loads->RowCount = 1;
	  StringGrid_N->RowCount = 1;
	  StringGrid_q->RowCount = 1;
	  Edit_X0Load->Text = 0;
	  Edit_Fz->Text = 0;
	  Edit_Fx->Text = 0;
	  Edit_My->Text = 0;

	  Edit_x0->Text = 0;
	  Edit_Len->Text = 0;
	  Edit_p1->Text = 0;
	  Edit_p2->Text = 0;

	  Edit_x0->Text = 0;
	  Edit_Len->Text = 0;
	  Edit_p1->Text = 0;
	  Edit_p2->Text = 0;

}
//-----------------------------------------------------------------



void __fastcall TRackLoadFrame::BitBtn_DeleteZagrClick(TObject *Sender)
{
	 #ifdef EMBRAC
	 int rc=Application->MessageBox(L"Удалить все загружения и опоры?", L"",
								  MB_YESNO | MB_ICONQUESTION);
	 #else
	 int rc=Application->MessageBox("Удалить все загружения и опоры?", "",
								  MB_YESNO | MB_ICONQUESTION);
	 #endif
	 if (rc==IDNO) return;
	 DeleteZagr(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::StringGrid_CombinSelectCell(TObject *Sender, int ACol,
		  int ARow, bool &CanSelect)
{
	CombRow = ARow;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButtonApp_ConstrClick(TObject *Sender)
{
	int i, rc;
	double x_rack = 0;
	double ss;
	double Pos_etagh[100];

	N_part = CSpinEdit_Etagh->Value;
	for (i=0; i<N_part; i++) {
	  if (StringGrid_koeff->Cells[1][i+1]=="") {
	  rc=Application->MessageBox((L"Не задана отметка участка "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[1][0], StringGrid_koeff->Cells[1][i+1], &ss);
	  if (rc>0) return;
	  if (ss - x_rack <0.01) {
		 rc=Application->MessageBox((L"Отметка участка стойки "+IntToStr(i+1)+" должна быть больше предыдущей отметки").c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  if (i==N_part - 1 && ss > Length_rack) {
		  rc=Application->MessageBox(L"Отметка последнего участка стойки должна быть равна длине стойки", L" ", MB_OK | MB_ICONERROR);
		  return;
	  }
	  Length_part[i] = ss - x_rack; // Длины участков
	  x_rack = ss;
	  Pos_etagh[i] = ss;
	  // Коэфф. XZ
	  if (StringGrid_koeff->Cells[2][i+1]=="") {
		 rc=Application->MessageBox((L"Не задан коэффициент расчетной длины XZ участка стойки "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[2][0], StringGrid_koeff->Cells[2][i+1], &ss);
	  if (rc>0) return;
	  Koeff_length_XZ[i] = ss; // Коэффициенты расчетной длины участков
	  // Коэфф. XY
	  if (StringGrid_koeff->Cells[3][i+1]=="") {
		 rc=Application->MessageBox((L"Не задан коэффициент расчетной длины XY участка стойки "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[3][0], StringGrid_koeff->Cells[3][i+1], &ss);
	  if (rc>0) return;
	  Koeff_length_XY[i] = ss; // Коэффициенты расчетной длины участков
	}
	// задание опор по этажам
	for (i=0; i<N_part - 1; i++) {
	  Edit_X0Constr->Text = Pos_etagh[i];
	  CheckBox_Tx->Checked = false;
	  CheckBox_Tz->Checked = true;
	  CheckBox_Ry->Checked = false;
	  BitBtn_AddClick(Sender);
	}

		  //rc = String_double_zero_plus(Label_muXY->Caption, Edit_muXY->Text, &Len_XY);
		  //if (rc>0) return;
		  //rc = String_double_zero_plus(Label_step_up->Caption, Edit_step_up->Text, &Step_up);
		  //if (rc>0) return;
		  rc = String_double_zero_plus(Label_step_down->Caption, Edit_step_down->Text, &Step_comp_rack);
		  if (rc>0) return;
		  if (Len_XY==0)
			Len_XY = Length_rack;
		  if (Step_up==0)
			Step_up = Len_XY;
		  //if (Step_down==0)
		  //	Step_down = Len_XY;
       index_raskr = 1;
	   ImageList1->GetBitmap(0, SpeedButtonApp_Constr->Glyph);
}
//---------------------------------------------------------------------------
// Создать РСУ
void __fastcall TRackLoadFrame::BitBtn_CreateRSUClick(TObject *Sender)
{
	 int i, j, k, m, rc;
	 float **matr_combin;
	 float **matr_res_w;
	 double *matr_V;  // Перемещения
	 Load *reac_combin;
	 Load *reac_w;
	 double MyPlus;
	 double	SigmaPlus[MAX_BEAM_DATA];
	 double	SigmaMinus[MAX_BEAM_DATA];
	 int k_w;
	 double q_down_comb;
	 double q_down_comb_LR;
	 double M_down_comb_LR;

     //SpeedButtonApp_ConstrClick(Sender);

	 if (flag_comb && n_comb>0) {
	   if (index_raskr == 0)  {
		 rc=Application->MessageBox(L"Не заданы раскрепления, РСУ не создаются", L" ", MB_OK | MB_ICONERROR);
         PageControl_BoundCond->ActivePage = TabSheet_Constr_Raskrep;
		 return;
       }
     }

	 if (!flag_comb || n_comb==0) {
		 rc=Application->MessageBox(L"Не заданы сочетания загружений, РСУ не создаются", L" ", MB_OK | MB_ICONWARNING);
		 BitBtn_CalculateClick(Sender);
		 // Здесь вызывается DrawOut
		 ListBox1Click(Sender);

		 return;
	 }
	 // Выполнить расчет, чтобы получить k_result
	 BitBtn_CalculateClick(Sender);
	 if (k_result==0)
	   return;

	 matr_combin = (float**)almat_f(k_result, 7, &rc);
	 ALLOCVEC_(reac_combin, beam_mod.constr_force_length, Load);
	 ALLOCVEC_(matr_V, k_result, double);
	 if (rc>0) {
	   rc = Application->MessageBox(L"Error almat_f", L" ", MB_OK | MB_ICONERROR);
	   return;
	 }

	 FRo_RSU = FRo_beam; // погонная масса стойки при которой были получены РСУ
	 Izz_RSU = I_beam; // Момент инерции при котором были получены прогибы

	 for (i=0; i<N_part; i++) {
	   for (j=0; j<6; j++) {
		 MaxQ[i][j] = MaxQ_W[i][j] = 0; // N, Q, M
		 MaxR[i][j] = MaxR_W[i][j] = 0; // N, Q, M
		 MaxM[i][j] = MaxM_W[i][j] = 0; // N, Q, M
		 MinM[i][j] = MinM_W[i][j] = 0; // N, Q, M
		 MaxSigma[i][j] = MaxSigma_W[i][j] = 0; // N, Q, M
		 MinSigma[i][j] = MinSigma_W[i][j] = 0; // N, Q, M
		 MaxN[i][j] = MaxN_W[i][j] = 0;
		 MinN[i][j] = MinN_W[i][j] = 0;
	   }
	   MaxQ[i][1] = 0; // N, Q, M
	   MaxR[i][1] = -1e6; // N, Q, M
	   MaxM[i][2] = -1e6; // N, Q, M
	   MinM[i][2] = 1e6; // N, Q, M
	   SigmaPlus[i] = -1e6;
	   SigmaMinus[i] = 1e6;
	   MaxN[i][0] = -1e6;
	   MinN[i][0] = 1e6;
	 }
	 MaxV = 0;
	 MaxV_W = 0;

	 double q_down;
	 double q_down_LR;
	 double M_down_LR;

	 for (k=0, k_w = -1; k<n_beam; k++) {   // Результаты для веса
	   if (flag_weight[k]) {
		 k_w = k;
		 // Взять регионы из депозитария
		 int rc = Get_beam_data(k_w);
		 if (rc>0)
		   return;
		 //---------------------------------------------------------------------------
		 // Выполнить расчет загружения
		 CalculateExecute(k_beam, false, &q_down,  &q_down_LR, &M_down_LR, Sender);
		 matr_res_w = (float**)almat_f(k_result, 7, &rc);
		 ALLOCVEC_(reac_w, beam_mod.constr_force_length, Load);
		 for (i=0; i<k_result; i++) {
		   for (j=0; j<7; j++) {
			  matr_res_w[i][j] = matr_result[i][j]*Koeff_gamma_f[k_w];
		   }
		   MaxV_W = MAX(MaxV_W, (ABS(matr_result[i][3])));
		 }
		 for (i=0; i<beam_mod.constr_force_length; i++) {
		   reac_w[i].X = beam_mod.ConstrForces[i].X;
		   reac_w[i].u = beam_mod.ConstrForces[i].u*Koeff_gamma_f[k_w];
		   reac_w[i].v = beam_mod.ConstrForces[i].v*Koeff_gamma_f[k_w];
		   reac_w[i].c = beam_mod.ConstrForces[i].c*Koeff_gamma_f[k_w];
		 }
		 break;
	   }
	 }
	 // Здесь вызывается DrawOut
	 ListBox1Click(Sender);
	 // Получить максимальный размер пролета
	 double *x_span;
	 ALLOCVEC_(x_span, beam_mod.constr_force_length + 2, double);
	 for (i=0; i<beam_mod.constr_force_length; i++) {
		   x_span[i] = beam_mod.ConstrForces[i].X;
	 }
	 x_span[i] = 0;
	 x_span[i+1] = Length_rack*1000;
	 rc = qsortk((char*)x_span, beam_mod.constr_force_length + 2, SDOUBLE);
	 Span = 0;

	 for (i=0; i<beam_mod.constr_force_length+1; i++) {
	   Span = MAX(Span, x_span[i+1] - x_span[i]);
	 }
	 FREEVEC_(x_span);

	 MaxMy_R = 0;
	 //--------------------------------------------------
	 // Цикл по числу комбинаций
	 q_down_max = 0.0;
	 q_down_LR_max = 0.0;
	 M_down_LR_max = 0;
	 for (m=0; m < n_comb; m++) {
	   q_down_comb = 0;
	   q_down_comb_LR = 0;
	   M_down_comb_LR = 0;
	   for (i=0; i<k_result; i++) {
		 matr_V[i] = 0;
		 for (j=0; j<7; j++)
			matr_combin[i][j] = 0;
	   }
	   for (i=0; i<beam_mod.constr_force_length; i++) {
		 reac_combin[i].u = 0;
		 reac_combin[i].v = 0;
		 reac_combin[i].c = 0;
	   }
	   // Цикл по числу загружений
	   for (k=0; k<n_beam; k++) {
		 // Взять регионы из депозитария
		 int rc = Get_beam_data(k);
		 if (rc>0)
		   return;
		 //---------------------------------------------------------------------------
		 // Выполнить расчет загружения
		 CalculateExecute(k_beam, false, &q_down, &q_down_LR, &M_down_LR, Sender);

		 q_down_comb += q_down*Koeff_gamma_f[k]*Combin_zagr[m][k];
		 q_down_comb_LR += q_down_LR*Koeff_gamma_f[k]*Combin_zagr[m][k];
		 M_down_comb_LR += M_down_LR*Koeff_gamma_f[k]*Combin_zagr[m][k];

		 for (i=0; i<k_result; i++) {
		   for (j=0; j<7; j++) {
			  matr_combin[i][j] += matr_result[i][j]*Koeff_gamma_f[k]*Combin_zagr[m][k];      //matr_combin[500][3]
		   }
		 }
		 // Прогибы
		 for (i=0; i<k_result; i++) {
		   matr_V[i] += matr_result[i][3]*Combin_zagr[m][k];      //matr_result[501][3]       matr_V[501]
		 }
		 // Реакции в опорах
		 for (i=0; i<beam_mod.constr_force_length; i++) {
		   reac_combin[i].X = beam_mod.ConstrForces[i].X;
		   reac_combin[i].u += beam_mod.ConstrForces[i].u*Koeff_gamma_f[k]*Combin_zagr[m][k];
		   reac_combin[i].v += beam_mod.ConstrForces[i].v*Koeff_gamma_f[k]*Combin_zagr[m][k];
		   reac_combin[i].c += beam_mod.ConstrForces[i].c*Koeff_gamma_f[k]*Combin_zagr[m][k];
		 }
	   }  // конец цикла по загружениям
	   if (q_down_max < q_down_comb) {
		  q_down_max = q_down_comb;
	   }
	   if (q_down_LR_max < q_down_comb_LR) {
		  q_down_LR_max = q_down_comb;
	   }
	   if (M_down_LR_max < M_down_comb_LR) {
		  M_down_LR_max = M_down_comb_LR;
	   }
	   // Максимальное перемещение
	   for (i=0; i<k_result; i++) {
		 MaxV = MAX(MaxV, (ABS(matr_V[i])));
	   }
	   double pos_part = Length_part[0]*L1000;  // отметка первого этажа
	   int ki = 0;  // номер этажа
	   for (i=0; i<k_result; i++) {
		 if (x_result[i] > pos_part) {
			ki++;
			if (ki > N_part) {
			  rc = Application->MessageBox(L"RackLoadFrame::BitBtn_CreateRSUClick:Программная ошибка", L" ", MB_OK | MB_ICONERROR);
			  return;
            }
			pos_part += Length_part[ki]*L1000;
		 }
		 if (MaxN[ki][0] < matr_combin[i][0]) {
			 MaxN[ki][0] = Round(matr_combin[i][0], -1);
			 MaxN[ki][1] = Round(matr_combin[i][1], -1);
			 MaxN[ki][2] = Round(matr_combin[i][2], -1);
			 MaxN[ki][5] = x_result[i];
			 if (k_w>=0) {
				MaxN_W[ki][0] = Round(matr_res_w[i][0], 0);
				MaxN_W[ki][1] = Round(matr_res_w[i][1], 0);
				MaxN_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (MinN[ki][0] > matr_combin[i][0]) {
			 MinN[ki][0] = Round(matr_combin[i][0], -1);
			 MinN[ki][1] = Round(matr_combin[i][1], -1);
			 MinN[ki][2] = Round(matr_combin[i][2], -1);
			 MinN[ki][5] = x_result[i];
			 if (k_w>=0) {
				MinN_W[ki][0] = Round(matr_res_w[i][0], 0);
				MinN_W[ki][1] = Round(matr_res_w[i][1], 0);
				MinN_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if ((ABS(MaxQ[ki][1])) < (ABS(matr_combin[i][1]))) {
			 MaxQ[ki][0] = Round(matr_combin[i][0], -1);
			 MaxQ[ki][1] = ABS(Round(matr_combin[i][1], -1));
			 MaxQ[ki][2] = Round(matr_combin[i][2], -1);
			 MaxQ[ki][5] = x_result[i];
			 if (k_w>=0) {
				MaxQ_W[ki][0] = Round(matr_res_w[i][0], 0);
				MaxQ_W[ki][1] = ABS(Round(matr_res_w[i][1], 0));
				MaxQ_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (MaxM[ki][2] < matr_combin[i][2]) {
			 MaxM[ki][0] = Round(matr_combin[i][0], -1);
			 MaxM[ki][1] = Round(matr_combin[i][1], -1);
			 MaxM[ki][2] = Round(matr_combin[i][2], -1);
			 MaxM[ki][5] = x_result[i];
			 if (k_w>=0) {
				MaxM_W[ki][0] = Round(matr_res_w[i][0], 0);
				MaxM_W[ki][1] = Round(matr_res_w[i][1], 0);
				MaxM_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (MinM[ki][2] > matr_combin[i][2]) {
			 MinM[ki][0] = Round(matr_combin[i][0], -1);
			 MinM[ki][1] = Round(matr_combin[i][1], -1);
			 MinM[ki][2] = Round(matr_combin[i][2], -1);
			 MinM[ki][5] = x_result[i];
			 if (k_w>=0) {
				MinM_W[ki][0] = Round(matr_res_w[i][0], 0);
				MinM_W[ki][1] = Round(matr_res_w[i][1], 0);
				MinM_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (SigmaMinus[ki] > matr_combin[i][5]) {
			 SigmaMinus[ki] = matr_combin[i][5];
			 MinSigma[ki][0] = Round(matr_combin[i][0], -1);
			 MinSigma[ki][1] = Round(matr_combin[i][1], -1);
			 MinSigma[ki][2] = Round(matr_combin[i][2], -1);
			 MinSigma[ki][5] = x_result[i];
			 if (k_w>=0) {
				MinSigma_W[ki][0] = Round(matr_res_w[i][0], 0);
				MinSigma_W[ki][1] = Round(matr_res_w[i][1], 0);
				MinSigma_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (SigmaMinus[ki] > matr_combin[i][6]) {
			 SigmaMinus[ki] = matr_combin[i][6];
			 MinSigma[ki][0] = Round(matr_combin[i][0], -1);
			 MinSigma[ki][1] = Round(matr_combin[i][1], -1);
			 MinSigma[ki][2] = Round(matr_combin[i][2], -1);
			 MinSigma[ki][5] = x_result[i];
			 if (k_w>=0) {
				MinSigma_W[ki][0] = Round(matr_res_w[i][0], 0);
				MinSigma_W[ki][1] = Round(matr_res_w[i][1], 0);
				MinSigma_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (SigmaPlus[ki] < matr_combin[i][5]) {
			 SigmaPlus[ki] = matr_combin[i][5];
			 MaxSigma[ki][0] = Round(matr_combin[i][0], -1);
			 MaxSigma[ki][1] = Round(matr_combin[i][1], -1);
			 MaxSigma[ki][2] = Round(matr_combin[i][2], -1);
			 MaxSigma[ki][5] = x_result[i];
			 if (k_w>=0) {
				MaxSigma_W[ki][0] = Round(matr_res_w[i][0], 0);
				MaxSigma_W[ki][1] = Round(matr_res_w[i][1], 0);
				MaxSigma_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
		 if (SigmaPlus[ki] < matr_combin[i][6]) {
			 SigmaPlus[ki] = matr_combin[i][6];
			 MaxSigma[ki][0] = Round(matr_combin[i][0], -1);
			 MaxSigma[ki][1] = Round(matr_combin[i][1], -1);
			 MaxSigma[ki][2] = Round(matr_combin[i][2], -1);
			 MaxSigma[ki][5] = x_result[i];
			 if (k_w>=0) {
				MaxSigma_W[ki][0] = Round(matr_res_w[i][0], 0);
				MaxSigma_W[ki][1] = Round(matr_res_w[i][1], 0);
				MaxSigma_W[ki][2] = Round(matr_res_w[i][2], 0);
			 }
		 }
	   }
	   // Определение максимальной реакции на опорах
	   for (ki=0; ki<N_part; ki++) {
		 //for (i=0; i<beam_mod.constr_force_length; i++) {
		   i = ki;
		   if (MaxR[ki][1]  < (ABS(reac_combin[i].v))) {
			 MaxR[ki][1] = ABS(reac_combin[i].v);
			 if (k_w>=0)
			   MaxR_W[ki][1] = ABS(reac_w[i].v);
			 for (j=0; j<k_result; j++) {
			   if (reac_combin[i].X == x_result[j]) {
				 MaxR[ki][0] = matr_combin[j][0];
				 MaxR[ki][2] = matr_combin[j][2];
				 if (k_w>=0) {
					MaxR_W[ki][0] = matr_res_w[j][0];
					MaxR_W[ki][2] = matr_res_w[j][2];
				 }
			   break;
			   }
			 }
		   }
		 //}
	   }
	   // Определение максимального момента на опорах
	   //for (i=0; i<beam_mod.constr_force_length; i++) {
	   for (i=0; i<N_part; i++) {
		   for (j=0; j<k_result; j++) {
			 if (reac_combin[i].X == x_result[j]) {
			   MaxMy_R = MAX((ABS(matr_combin[j][2])), MaxMy_R);
			 }
		 }
	   }
	 }
	 double maxM;
	 for (i=0; i<N_part; i++) {
	   maxM = MAX((ABS(MaxM[i][2])), (ABS(MinM[i][2])));
	 }
	 if (maxM > 0)
	   MaxMy_R /= maxM;

	 FREEMAT_(matr_combin);
	 FREEVEC_(reac_combin);
	 FREEVEC_(matr_V);
	 if (k_w>=0) {
	   FREEMAT_(matr_res_w);
	   FREEVEC_(reac_w);
	 }
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_CallCombinClick(TObject *Sender)
{
	  int i, j, rc;
	 // Записать текущщее загружение
	   PutZagrToDepo();

	   CombLoadForm->PutZagr(n_beam, type_zagr, n_comb, Combin_zagr, flag_comb);

	   CombLoadForm->ShowModal();

	   CombLoadForm->GetComb(&flag_comb, &n_comb);

	   if (flag_comb) {
		 FREEMAT_(Combin_zagr);
		 ALLOCMAT_(Combin_zagr, n_comb, n_beam);
		 for(i=0; i<n_comb; i++) {
			 for (j=0; j<n_beam; j++)
			   Combin_zagr[i][j] = CombLoadForm->CombStr[i][j];
		 }
		 PageControl_BoundCond->ActivePage = TabSheet_Combin;
		 TabSheet_Combin->TabVisible = true;
		 SpeedButton_CallCombin->Glyph->Width=0;
		 ImageList1->GetBitmap(0, SpeedButton_CallCombin->Glyph);
		 //SpeedButton_CallCombin->Glyph->ReleaseHandle();
		 SpeedButton_CallCombin->Tag = 1 - SpeedButton_CallCombin->Tag;

	   }
	   PageControl_BoundCondChange(Sender);

}
//-------------------------------------------------------------------

void __fastcall TRackLoadFrame::Correct_Weight()
{
int k;
   for (int i=0; i<n_beam; i++) {
	   if (flag_weight[i]) {
		 if (i==0)
		   k = 0;
		 else
		   k = index_beam[i-1][1];
		 N_v[k].begValue = Round(-FRo_beam*9.81*1e-3, 3);
		 N_v[k].endValue = Round(-FRo_beam*9.81*1e-3, 3);
	   }
   }
   if (Label_Weight->Visible) {
	   Edit_n1->Text = FloatToStrF(-FRo_beam*9.81*1e-3,ffFixed, 8, 3);
	   Edit_n2->Text = FloatToStrF(-FRo_beam*9.81*1e-3,ffFixed, 8, 3);
	   StringGrid_N->Cells[3][1] = Edit_n1->Text;
	   StringGrid_N->Cells[4][1] = Edit_n2->Text;
	   N_[0].begValue = Round(-FRo_beam*9.81*1e-3, 3);
	   N_[0].endValue = Round(-FRo_beam*9.81*1e-3, 3);

	   //k = ComboBox_num_zagr->ItemIndex;
	   Put_beam_data();
   }
}
//----------------------------------------------------------------------------------
void __fastcall TRackLoadFrame::SpeedButtonFix_FreeClick(TObject *Sender)
{
   if (SpeedButtonFix_Free->Down) {
	 StringGrid_Constr->RowCount = 1;

	 Edit_X0Constr->Text = "0";
	 CheckBox_Tx->Checked = true;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = true;
	 BitBtn_AddClick(Sender);
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XZ[0] = 2.0;
	   StringGrid_koeff->Cells[2][1] = Koeff_length_XZ[0];
	 }
   }
   flag_constr = false;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButtonFix_PinClick(TObject *Sender)
{
   if (SpeedButtonFix_Pin->Down) {
	 StringGrid_Constr->RowCount = 1;

	 Edit_X0Constr->Text = "0";
	 CheckBox_Tx->Checked = true;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = true;
	 BitBtn_AddClick(Sender);

	 Edit_X0Constr->Text = FloatToStr(Length_rack);
	 CheckBox_Tx->Checked = false;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = false;
	 BitBtn_AddClick(Sender);
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XZ[0] = 0.7;
	   StringGrid_koeff->Cells[2][1] = Koeff_length_XZ[0];
	 }
   }
   flag_constr = false;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButtonPin_FixClick(TObject *Sender)
{
   if (SpeedButtonPin_Fix->Down) {
	 StringGrid_Constr->RowCount = 1;

	 Edit_X0Constr->Text = "0";
	 CheckBox_Tx->Checked = true;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = false;
	 BitBtn_AddClick(Sender);

	 Edit_X0Constr->Text = FloatToStr(Length_rack);
	 CheckBox_Tx->Checked = false;
	 CheckBox_Tz->Checked = true;
	 CheckBox_Ry->Checked = true;
	 BitBtn_AddClick(Sender);
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XZ[0] = 0.7;
	   StringGrid_koeff->Cells[2][1] = Koeff_length_XZ[0];
	 }
   }
   flag_constr = false;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::CSpinEdit_EtaghChange(TObject *Sender)
{
	 int i;
	 StringGrid_koeff->RowCount = CSpinEdit_Etagh->Value + 1;
	 if (CSpinEdit_Etagh->Value>1) {
		 StringGrid_koeff->Cells[1][0] = "Отметка верха, м";
		 for (i=0; i<CSpinEdit_Etagh->Value; i++) {
			StringGrid_koeff->Cells[0][i+1] = i+1;
			StringGrid_koeff->Cells[1][i+1] = "";
			StringGrid_koeff->Cells[2][i+1] = "";
			StringGrid_koeff->Cells[3][i+1] = "";
		 }
		 StringGrid_koeff->Cells[1][i] = Length_rack;

	 }
	 else {
			StringGrid_koeff->Cells[1][0] = "Высота, м";
			StringGrid_koeff->Cells[0][1] = 1;
			StringGrid_koeff->Cells[1][1] = Length_rack;
            Length_part[0] = Length_rack;
	 }
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_XY_fixClick(TObject *Sender)
{
   if (SpeedButton_XY_fix->Down) {
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XY[0] = 2.0;
	   StringGrid_koeff->Cells[3][1] = Koeff_length_XY[0];
	 }
   }
   index_TY_up = 0;
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_XY_fix_pinClick(TObject *Sender)
{
   if (SpeedButton_XY_fix_pin->Down) {
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XY[0] = 0.7;
	   StringGrid_koeff->Cells[3][1] = Koeff_length_XY[0];
	 }
   }
   index_TY_up = 1;

}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_XY_fix_fixClick(TObject *Sender)
{
   if (SpeedButton_XY_fix_fix->Down) {
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XY[0] = 0.5;
	   StringGrid_koeff->Cells[3][1] = Koeff_length_XY[0];
	 }
   }
   index_TY_up = 1;
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_XY_pin_pinClick(TObject *Sender)
{
   if (SpeedButton_XY_pin_pin->Down) {
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XY[0] = 1.0;
	   StringGrid_koeff->Cells[3][1] = Koeff_length_XY[0];
	 }
   }
   index_TY_up = 1;
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::SpeedButton_XY_pin_fixClick(TObject *Sender)
{
   if (SpeedButton_XY_pin_fix->Down) {
	 if (CSpinEdit_Etagh->Value==1) {
	   Koeff_length_XY[0] = 0.7;
	   StringGrid_koeff->Cells[3][1] = Koeff_length_XY[0];
	 }
   }
   index_TY_up = 1;
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::BitBtn_ApplyConstrClick(TObject *Sender)
{
	int i, rc;
	double x_rack = 0;
	double ss;
	double Pos_etagh[100];

	N_part = CSpinEdit_Etagh->Value;
	for (i=0; i<N_part; i++) {
	  if (StringGrid_koeff->Cells[1][i+1]=="") {
	  rc=Application->MessageBox((L"Не задана отметка стойки "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[1][0], StringGrid_koeff->Cells[1][i+1], &ss);
	  if (rc>0) return;
	  if (ss - x_rack <0.01) {
		 rc=Application->MessageBox((L"Отметка участка стойки "+IntToStr(i+1)+" должна быть больше предыдущей отметки").c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  if (i==N_part - 1 && ss > Length_rack) {
		  rc=Application->MessageBox(L"Отметка последнего участка стойки должна быть равна длине стойки", L" ", MB_OK | MB_ICONERROR);
		  return;
	  }
	  Length_part[i] = ss - x_rack; // Длины участков
	  x_rack = ss;
	  Pos_etagh[i] = ss;
	  // Коэфф. XZ
	  if (StringGrid_koeff->Cells[2][i+1]=="") {
		 rc=Application->MessageBox((L"Не задан коэффициент расчетной длины XZ участка стойки "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[2][0], StringGrid_koeff->Cells[2][i+1], &ss);
	  if (rc>0) return;
	  Koeff_length_XZ[i] = ss; // Коэффициенты расчетной длины участков
	  // Коэфф. XY
	  if (StringGrid_koeff->Cells[3][i+1]=="") {
		 rc=Application->MessageBox((L"Не задан коэффициент расчетной длины XY участка стойки "+IntToStr(i+1)).c_str(), L" ", MB_OK | MB_ICONERROR);
		 return;
	  }
	  rc=String_double_plus(StringGrid_koeff->Cells[3][0], StringGrid_koeff->Cells[3][i+1], &ss);
	  if (rc>0) return;
	  Koeff_length_XY[i] = ss; // Коэффициенты расчетной длины участков
	}
	// задание опор по этажам
	for (i=0; i<N_part - 1; i++) {
	  Edit_X0Constr->Text = Pos_etagh[i];
	  CheckBox_Tx->Checked = false;
	  CheckBox_Tz->Checked = true;
	  CheckBox_Ry->Checked = false;
	  BitBtn_AddClick(Sender);
	}
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::BitBtn_AddElemClick(TObject *Sender)
{
   CSpinEdit_Etagh->Value++;
}
//---------------------------------------------------------------------------

void __fastcall TRackLoadFrame::BitBtn_DelElemClick(TObject *Sender)
{
     CSpinEdit_Etagh->Value--;

}
//---------------------------------------------------------------------------

