//---------------------------------------------------------------------------
//  Выполнить проверку профиля или группы профилей
static bool flag_warning_razrez;
static bool flag_warning_steel;

int __fastcall TSelectProfilSectForm::Executive(int index, int index_thick,
												double *mass_prof, int *num_prof, TObject *Sender)
{
  // index - номер профиля  (если -1, поиск)
  // n_thick - номер толщины трубы, задается при проверке трубы
   AnsiString *NameProfil;
   int n_profil, i, j, k;
   double mass[500], mass0;
	  double *param_prof;
   double *thick;
   int  n_thick;
   int  num_thick;  // количество толщин
   int i_prof[500];
   int n_mass;
   int min_prof;
   int rc;
   int number_profil;  // Порядковый номер профиля
   int iW;
   int rc_check;
   bool flag_fall_mater;  // Нарушение ограничения по материалу
   int max_prof = 0;
   int max_thick = 0;
   double Ar;
   int len_profil; // длина вектора имен - количество профилей в номенклатуре

   double plate_width;
   double plate_thick;
   double kf_comp;

   Flag_fall_mater = false;
   flag_warning_razrez = false;
   flag_warning_steel = false;

   // Установка начальных значений для критериев
   for (i=0; i<NUMBER_CHECK; i++) {
	 for (j=0; j<30; j++) {
	   Krit[i][j] = -1;
	 }
   }
   //------------------------------------------------------------------
   // Установить один из сортаментов в случае прокатных сечений
   switch (Data_select.form_profil) {
   case DVUTAVR_STAND:                         // Прокатной двутавр
   case PERFOR_BEAM:
   // Установить тип стандартного сечения
	 StandartProfil.SetProfil(Data_select.type_profil);
   // Получить вектор имен профилей и длину вектора
	 NameProfil = StandartProfil.GetVectorNameProfil(&len_profil);
	 iW = parWEIGHT_DVUTAVR;
   break;
   case TRUBA:                                 // Труба
	 StandartProfil.SetProfil_Tube(Data_select.type_profil);
   // Получить вектор имен профилей и длину вектора
	 NameProfil = StandartProfil.GetVectorNameProfil(&len_profil);
	 switch (Data_select.type_profil) {
	 case typeSQUARE:
	   iW = parWEIGHT_SQUARE_TUBE;
	 break;
	 case typeRECT:
	   iW = parWEIGHT_RECT_TUBE;
	 break;
	 case typeCIRC:
	   iW = parWEIGHT_CIRC_TUBE;
	 break;
	 }
   break;
   case DVUTAVR_WELD:                           // Сварной двутавр
	 ;
   break;
   case COMPOSED_BEAM:                         // Составная балка
	switch (Data_select.index_composed) {
	case TAVR_PLATE_DOWN:
	case TAVR_PLATE_UP:
	   Data_select.type_profil = Data_select.index_profil + typeTAVR_BT;
	   StandartProfil.SetProfil(Data_select.type_profil);


	   //rc = StandartProfil.SetParamProfil(&(com_sect.dvutavr), n_profil);
	   //if (rc>0) return rc;
	   // Получить вектор имен профилей и длину вектора
	   NameProfil = StandartProfil.GetVectorNameProfil(&len_profil);
	   iW = parWEIGHT_TAVR;
	 break;
	 case DVUTAVR_PLATE_DOWN:
	   Data_select.type_profil = Data_select.index_profil + typeGOST_G57837_B;
	   StandartProfil.SetProfil(Data_select.type_profil);


	   //rc = StandartProfil.SetParamProfil(&(com_sect.dvutavr), n_profil);
	   //if (rc>0) return rc;

	   // Получить вектор имен профилей и длину вектора
	   NameProfil = StandartProfil.GetVectorNameProfil(&len_profil);
	   iW = parWEIGHT_DVUTAVR;
	 break;
	 }
   break;
   }
   //-------------------------------------------------------
   // Подбор сечения или расчет для заданного профиля сечения
   //--------------------------------------------------------
   if (index != -1) {
   //-------------------------------------------------------------------
   // Профиль задан, подсчет массы
   //-------------------------------------------------------------------
	 switch (Data_select.form_profil) {
	 case DVUTAVR_STAND:                     // Прокатной двутавр
	   // Заполнить структуру параметров сечения двутавра по его номеру
	   rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), index);
	   if (rc >0) return rc;
	   min_prof = index;
	   param_prof = StandartProfil.GetVectorParamProfil(index);
	   mass0 = 0;
	   for (j=0; j<Data_select.N_plane; j++) {
			mass0 += param_prof[iW]*Data_select.Length[j]/1000;
	   }
	 break;
	 case PERFOR_BEAM:
	   // Заполнить структуру параметров сечения двутавра по его номеру
	   rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), index);
	   if (rc >0) return rc;
	   min_prof = index;
	   param_prof = StandartProfil.GetVectorParamProfil(index);
	   mass0 = 0;
	   for (j=0; j<Data_select.N_plane; j++) {
			mass0 += param_prof[iW]*Data_select.Length[j]/1000;
	   }
	 break;
	 case TRUBA:                              // Труба
	   // Получить вектор толщин профиля трубы по номеру группы (h*b) и их количество
	   thick = StandartProfil.GetVectorParamThickness_Tube(index, &num_thick);
	   // Получение порядкового номера
	   min_prof = StandartProfil.GetNumberProfil_Tube(index, index_thick);
	   // Заполнить структуру параметров сечения двутавра по его номеру
	   rc = StandartProfil.SetParamProfil_Tube(&(CheckExecute.Sect_Elem_Group[0].com_sect), Data_select.type_profil, min_prof, 0);
	   if (rc >0) return rc;
	   param_prof = StandartProfil.GetVectorParamProfil_Tube(index, index_thick);
	   mass0 = 0;
	   for (j=0; j<Data_select.N_plane; j++) {
			mass0 += param_prof[iW]*Data_select.Length[j]/1000;
	   }
	 break;
	 case DVUTAVR_WELD:  // Сварной двутавр
	   mass0 = 0;
	   Ar = sect_w->h * sect_w->b + sect_w->b1 * sect_w->h1 + sect_w->b2 * sect_w->h2;

	   for (j=0; j<Data_select.N_plane; j++) {
		  mass0 += 7.85e-6*Ar*Data_select.Length[j];
	   }

	 break;
	 case COMPOSED_BEAM:                     // Прокатной двутавр
	   switch (Data_select.index_composed) {
		case TAVR_PLATE_DOWN:
		case TAVR_PLATE_UP:
	   // Заполнить структуру параметров сечения двутавра по его номеру
		 rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), index);
		 if (rc >0) return rc;
		 min_prof = index;
		 param_prof = StandartProfil.GetVectorParamProfil(index);
		 mass0 = 0;
		 for (j=0; j<Data_select.N_plane; j++) {
			mass0 += param_prof[iW]*Data_select.Length[j]/1000;
			mass0 += 7.85e-6*Data_select.plate_thick*Data_select.plate_thick*Data_select.Length[j];
		 }
	   break;
	   case DVUTAVR_PLATE_DOWN:
	   // Заполнить структуру параметров сечения двутавра по его номеру
		 rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), index);
		 if (rc >0) return rc;
		 min_prof = index;
		 param_prof = StandartProfil.GetVectorParamProfil(index);
		 mass0 = 0;
		 for (j=0; j<Data_select.N_plane; j++) {
			mass0 += param_prof[iW]*Data_select.Length[j]/1000;
			mass0 += 7.85e-6*Data_select.plate_thick*Data_select.plate_thick*Data_select.Length[j];
		 }
	   break;
	   }
	 break;
	 }
	 //min_prof = index;
   }
   else {
   //-------------------------------------------------------------------
   // Профиль не задан
   //-------------------------------------------------------------------
	 double h0;
	 double k_att;
	 double perfor_h;

	 switch (Data_select.form_profil) {
	 case DVUTAVR_STAND:                             // Поиск профиля двутаврв в сортаменте
	 case TRUBA:                                     // Прокатное сечение из сортамента
	 case PERFOR_BEAM:
	 case COMPOSED_BEAM:                     // Составное сечение
       n_mass = 0;
	   int j ;
	   min_prof = -1;
	  //-------------------------------------------------------------------------
	  // Цикл по номенклатуре профилей
	   for (i=0; i<len_profil; i++) {
		 if (i==14) {    // Для отладки
		   rc = 0;
		 }
		 switch(Data_select.form_profil) {
		 case DVUTAVR_STAND:   // Прокатной двутавр, проверка ограничений
		   rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), i);
		   if (rc >0) return rc;
		   if (Data_select.flag_add_limit) {
			 if (Data_select.max_width > 0 && CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b1 > Data_select.max_width) {
			   continue;
			 }
			 if (Data_select.max_height &&
				(2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h1 + CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h) > Data_select.max_height) {
			   continue;
			 }

		   }
		   num_thick = 1;
		 break;
		 case PERFOR_BEAM:
		  // Проверка ограничений выполняется
		   rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), i);
		   if (rc >0) return rc;

		   h0 = CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h + 2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h1;
		   k_att = Data_select.perfor_attit/3;
		   perfor_h = Round(k_att*h0, 0) - 1;

		   h0 += perfor_h;
		   if (Data_select.flag_add_limit) {
			 if (Data_select.max_width > 0 && CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b1 > Data_select.max_width) {
			   continue;
			 }
			 if (Data_select.max_height && h0 > Data_select.max_height) {
			   continue;
			 }

		   }
		   num_thick = 1;
		 break;
		 case TRUBA:                                           // Труба
		   rc = StandartProfil.SetParamProfil_Tube(&(CheckExecute.Sect_Elem_Group[0].com_sect), Data_select.type_profil, i, 0);
		   if (rc >0) return rc;
		   thick = StandartProfil.GetVectorParamThickness_Tube(i, &num_thick);
		   if (thick==NULL) return 1;
		 break;
		 case COMPOSED_BEAM:                     // Составное сечение
		   switch (Data_select.index_composed) {
		   case TAVR_PLATE_DOWN:
		   case TAVR_PLATE_UP:
			 rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), i);
			 if (rc >0) return rc;
			 if (Data_select.flag_add_limit) {
			   if (Data_select.max_width > 0 && CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b1 > Data_select.max_width) {
				 continue;
			   }
			   if (Data_select.max_height &&
				(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h1 + CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h) > Data_select.max_height) {
				 continue;
			   }
			 }
		   // получить параметры плиты и шва
			 Get_plate_param(Data_select.index_composed, &(CheckExecute.Sect_Elem_Group[0].com_sect), &plate_width, &plate_thick, &kf_comp);

			 if (plate_width < 2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b)
			   continue;

			 Data_select.plate_width = plate_width;
			 Data_select.plate_thick = plate_thick;
			 Data_select.kf_comp = MAX(kf_comp, Data_select.kf_comp);
			 num_thick = 1;
		   break;
		   case DVUTAVR_PLATE_DOWN:
			 if (Data_select.flag_add_limit) {
			   if (Data_select.max_width > 0 && CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b1 > Data_select.max_width) {
				 continue;
			   }
			   if (Data_select.max_height &&
				(2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h1 + CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.h) > Data_select.max_height) {
				 continue;
			   }
			 }
			 Get_plate_param(Data_select.index_composed, &(CheckExecute.Sect_Elem_Group[0].com_sect), &plate_width, &plate_thick, &kf_comp);

			 if (plate_width < 2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b)
			   continue;

			 Data_select.plate_width = plate_width;
			 Data_select.plate_thick = plate_thick;
			 Data_select.kf_comp = MAX(kf_comp, Data_select.kf_comp);
			 num_thick = 1;
		   break;
		   }
		 break;
		 }
		//-----------------------------------------------------------------
		// Выполнить проверку по СП для профиля i с числом толщин num_thick
		 int n_prof_check = 0;
		 for (j=0; j<num_thick; j++) {
		   Name_prof = NameProfil[i];
		   //InfMessage((AnsiString)Name_prof + ": i="+IntToStr(i)+"; j="+IntToStr(j));
		   //---------------------------------------------------------
		   int cod_check = Check_profil(i, j, &flag_fall_mater);
		   if (cod_check == steel_NO_STEEL)
             return cod_check;
		   //InfMessage("cod_check = "+IntToStr(cod_check));
		   //--------------------------------------------------------------
		   if (!flag_fall_mater) {  // ограничение по толщине не было нарушено
			 max_prof = i;
			 max_thick = j;
			 //InfMessage("     max_prof = "+IntToStr(max_prof));
		   }
		   else {
			 n_prof_check++;
			 Flag_fall_mater = true;
		   }
		   if (cod_check == 0) {    // Проверка профиля прошла - все критерии меньше или равны 1.0
		   // Подсчет массы
			 mass[n_mass] = 0;

			 switch (Data_select.form_profil) {
			 case DVUTAVR_STAND:  // Двутавр
			 case PERFOR_BEAM:
			   param_prof = StandartProfil.GetVectorParamProfil(i);
			   number_profil = i;
			   for (k=0; k<Data_select.N_plane; k++) {
				 mass[n_mass] += param_prof[iW]*Data_select.Length[k]/1000;
			   }
			 break;
			 case TRUBA:   // Труба
			   param_prof = StandartProfil.GetVectorParamProfil_Tube(i, j);
			   number_profil = StandartProfil.GetNumberProfil_Tube(i, j);
			   for (k=0; k<Data_select.N_plane; k++) {
				 mass[n_mass] += param_prof[iW]*Data_select.Length[k]/1000;
			   }
			 break;
			 case COMPOSED_BEAM:                     // Прокатной двутавр
			   param_prof = StandartProfil.GetVectorParamProfil(i);
			   number_profil = i;
			   for (k=0; k<Data_select.N_plane; k++) {
				 mass[n_mass] += param_prof[iW]*Data_select.Length[k]/1000;
				 mass[n_mass] += 7.85e-6*Data_select.plate_thick*Data_select.plate_thick*Data_select.Length[j];
			   }
			 break;
			 }
			 //InfMessage("number_prof="+IntToStr(cod_check) + "; mass="+FloatToStr(mass[n_mass]));
			 i_prof[n_mass] = number_profil;
			 n_mass++;
		   }
		   else {
			 if (cod_check >= 99) // неверные РСУ
				 return cod_check;
		   // Проверка профиля трубы не прошла - есть критерии больше 1.0
		   // поиск минимального критерия

		   }
		 }
	   }
	   mass0 = 1e12;
	   min_prof = -1;
	   for (i=0; i<n_mass; i++) {
		 if (mass[i] < mass0) {
		   mass0 = mass[i];
		   min_prof = i_prof[i];
		 }
	   }
	 break;
	 case DVUTAVR_WELD:   // Подбор сечений сварного двутавра

		// Подбор сечений для вех участков и по  всем РСУ
		rc = Chosen_Weld(&mass0);
		if (rc>0)
		  return rc;
		//-------------------------------------------------
		// Отображение сварного сечения
		//-------------------------------------------------
		Sect_Param_WeldFrame1->kf_dvut = Data_select.kf_comp;
		Sect_Param_WeldFrame1->Write_sect(Sender);
		Label_mass_weld->Caption = "Масса профиля "+FloatToStr(Round(mass0 ,1))+ " кг";
		TabSheet_sect_prof->TabVisible = false;
		PageControl_Data->ActivePage = TabSheet_Weld;
	 }
   }

   if (min_prof == -1) {  // Профиль не найден, устанавливается последний проверенный профиль в сортаменте
	   switch (Data_select.form_profil) {
	   case DVUTAVR_STAND: // Двутавр
	   case PERFOR_BEAM: // Двутавр
			 //min_prof = n_profil - 1;
			 min_prof = max_prof;
			 param_prof = StandartProfil.GetVectorParamProfil(min_prof);
	   break;
	   case TRUBA:    // Труба
		 // Получить порядковый номер профиля трубы по номеру группы (h*b) и номеру внутри группы (t)
		 min_prof = StandartProfil.GetNumberProfil_Tube(max_prof, max_thick);
		 rc = StandartProfil.GetGroup_a_Profil_Tube(min_prof, &n_profil, &n_thick);
		 // Получить вектор параметров профиля трубы по порядковому номеру профиля
		 param_prof = StandartProfil.GetVectorParamProfil_TubeNum(min_prof);
	   break;
	   case COMPOSED_BEAM:                     // Прокатной двутавр
			 min_prof = max_prof;
			 param_prof = StandartProfil.GetVectorParamProfil(min_prof);
		 break;
	   }
	   mass0 = 0;
	   for (j=0; j<Data_select.N_plane; j++) {
		 mass0 += param_prof[iW]*Data_select.Length[j]/1000;
	   }
	   rc_check = 1;
   }
   else
	  rc_check = 0;
   //----------------------------------------------------------------------
   // Установка n_profil и n_thick по min_prof
   //----------------------------------------------------------------------
   switch (Data_select.form_profil) {
   case TRUBA: // Труба
	 // Получить  номер группы (n_profil) и номер внутри группы (n_thick) по порядковому номеру профиля трубы (min_prof)
	 rc = StandartProfil.GetGroup_a_Profil_Tube(min_prof, &n_profil, &n_thick);
	 Name_prof = NameProfil[n_profil];
   break;
   case DVUTAVR_STAND:  // Двутавр
   case PERFOR_BEAM:  // Двутавр
	 n_profil = min_prof;
	 n_thick = 1;
	 Name_prof = NameProfil[n_profil];
   break;
   case  DVUTAVR_WELD:  // Сварной двутавр
	 //Data_select.index_edge = 1;
	 Name_prof = " ";
   break;
   case COMPOSED_BEAM:  // Двутавр
	 n_profil = min_prof;
	 n_thick = 1;
	 Name_prof = NameProfil[n_profil];
	 rc = StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), n_profil);

	 Get_plate_param(Data_select.index_composed, &(CheckExecute.Sect_Elem_Group[0].com_sect), &plate_width, &plate_thick, &kf_comp);

	 plate_width = MAX(plate_width, 2*CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr.b);

	 Data_select.plate_width = plate_width;
	 Data_select.plate_thick = plate_thick;
	 Data_select.kf_comp = MAX(kf_comp, Data_select.kf_comp);

   break;
   }
   //-----------------------------------------------------------------------------------------
   // Выполнить проверку для профиля минимальной массы n_profil с числом толщин n_thick, чтобы получить критерии
   //-----------------------------------------------------------------------------------------
   rc = Check_profil(n_profil, n_thick, &flag_fall_mater);
   if (rc>0) {
	 rc_check = rc;
   }

   krit_max = 0;

   for (j=0; j < NUMBER_CHECK; j++) {        // Цикл по числу проверок
	 for (i=0; i<Data_select.N_check[j]; i++) {
	   if (krit_max < Krit[j][i]) {
		 krit_max = Krit[j][i];
		 nnel_max = Nnel_Krit[j][i];
		 check_max = j;
	   }
	 }
   }

   *mass_prof = mass0;
   *num_prof = min_prof;
   // Определить участок и РСУ, на котором значения критерия максимальны

   return rc_check;
}
//--------------------------------------------------------------------------------
// Подбор сечения сварного двутавра по всем участкам и РСУ
int __fastcall TSelectProfilSectForm::Chosen_Weld(double *mass_prof) {

	  int i, j, k;
	  double mat_stress[5];  // N, Qy, Mz, Qz, My
	  double mat_stress2[5];  // N, Qy, Mz, Qz, My  для опор
	  bool Check_dvutavr[6];
	  double N_, M_, Ry, hN, hM, h0;
	  double lambda0;
	  SECT_DVUTAVR sect_weld1;
	  SECT_DVUTAVR sect_weld2;


	  *mass_prof = 1e9;
	  lambda0 = Param_chosen_sect.lambda0;

	  Check_dvutavr[0] = Sect_Param_WeldFrame1->CheckBox_b1->Checked;
	  Check_dvutavr[1] = Sect_Param_WeldFrame1->CheckBox_h1->Checked;
	  Check_dvutavr[2] = Sect_Param_WeldFrame1->CheckBox_b->Checked;
	  Check_dvutavr[3] = Sect_Param_WeldFrame1->CheckBox_h->Checked;
	  Check_dvutavr[4] = Sect_Param_WeldFrame1->CheckBox_b2->Checked;
	  Check_dvutavr[5] = Sect_Param_WeldFrame1->CheckBox_h2->Checked;

	  double mass_1 = 1e9, mass_2 = 1e9;
	  sect_w = &sect_weld;

	  GEOM_PARAM_SECT param_sect;
	  if (Data_select.form_profil==COMPOSED_BEAM) {
		Get_param_sect_composed(CheckExecute.Sect_Elem_Group[0].type_sect, &(CheckExecute.Sect_Elem_Group[0].com_sect),
							  Data_select.plate_width, Data_select.plate_thick, &param_sect, Data_select.index_composed);
	  }
	  else {
		Get_param_sect_comm(CheckExecute.Sect_Elem_Group[0].type_sect, &(CheckExecute.Sect_Elem_Group[0].com_sect), &param_sect);
	  }
	  double FRo_curr = param_sect.Ar*7850*1e-6;

	  double Izz_RSU = BalkaLoadFrame1->Izz_RSU;

	  // Вычисление максимального прогиба
	  if (Data_select.index_loads==1) {  // Воздействие задано в форме загружений
		 Data_select.MaxV = (Data_select.MaxV0 + Data_select.MaxV_W*(FRo_curr/Data_select.FRo_RSU - 1))*Data_select.Izz_RSU/param_sect.Izz;

	  }
	  else {
		Data_select.MaxV = 0;
	  }

	  for (i = 0; i < Data_select.N_plane; i++) {
		for (j=0; j < Data_select.N_RSU[i]; j++) {
		  if (Data_select.q_bal[i][j] == 0) {
			//CheckExecute.q_bal[n_rsu][0] = CheckExecute.q_bal[n_rsu][1] = 0;    // qy
			mat_stress[0] = Data_select.RSU[i][j][0]*1e3*Data_select.gamma_n;
			mat_stress[1] = Data_select.RSU[i][j][1]*1e6*Data_select.gamma_n;
			mat_stress[2] = Data_select.RSU[i][j][2]*1e3*Data_select.gamma_n;
			mat_stress[3] = Data_select.RSU[i][j][3]*1e6*Data_select.gamma_n;
			mat_stress[4] = Data_select.RSU[i][j][4]*1e3*Data_select.gamma_n;
			if (RadioGroup_Loads->ItemIndex==1) {    // Воздействие задано в форме загружений
				mat_stress[0] += Data_select.RSU_W[j][0]*1e3*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
				mat_stress[1] += Data_select.RSU_W[j][1]*1e6*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
				mat_stress[2] += Data_select.RSU_W[j][2]*1e3*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
				mat_stress[3] += Data_select.RSU_W[j][3]*1e6*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
				mat_stress[4] += Data_select.RSU_W[j][4]*1e3*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
			}
		  }
		  else {
			// РСУ в центре
			mat_stress[0] = Data_select.RSU[i][j][0]*1e3*Data_select.gamma_n;
			mat_stress[1] = Data_select.RSU[i][j][1]*1e6*Data_select.gamma_n -
							Data_select.q_bal[i][j]*1e6*Data_select.Length[i]*Data_select.Length[i]*Data_select.gamma_n*1e-6/8 ;
			mat_stress[2] = Data_select.RSU[i][j][2]*1e3*Data_select.gamma_n;
			mat_stress[3] = Data_select.RSU[i][j][3]*1e6*Data_select.gamma_n;
			mat_stress[4] = Data_select.RSU[i][j][4]*1e3*Data_select.gamma_n;
			// РСУ на опорах
			mat_stress2[0] = Data_select.RSU[i][j][0]*1e3*Data_select.gamma_n;
			mat_stress2[1] = Data_select.RSU[i][j][1]*1e6*Data_select.gamma_n ;
			mat_stress2[2] = Data_select.RSU[i][j][2]*1e3*Data_select.gamma_n;
			mat_stress2[3] = Data_select.RSU[i][j][3]*1e6*Data_select.gamma_n -
							 Data_select.q_bal[i][j]*1e-3*Data_select.Length[i]*Data_select.gamma_n*1e-3/2 ; // Qy;
			mat_stress2[4] = Data_select.RSU[i][j][4]*1e3*Data_select.gamma_n;
			CheckExecute.q_bal_n[1][0] =  Data_select.Krn*Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
			CheckExecute.q_bal_r[1][0] =  Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
		  }
		 //--------------------------------
		 // Начальное приближение
		  N_ = ABS(mat_stress[0]);
		  M_ = ABS(mat_stress[1]);
		  Ry = MaterProp[Material_Number].Ry;

		  hN=sqrt(lambda0*N_/(2*Ry));
		  hM=pow(3*lambda0*M_/(2*Ry), 1e0/3);
		  h0 = MAX(hN, hM);
		  int rc_1 = 1;
		  int rc_2 = 1;
		  //
		  if (ComboBox_Alg->ItemIndex==0 || ComboBox_Alg->ItemIndex==1) {
			if (Param_chosen_sect.size_a==0) {
			  int rc=Application->MessageBox(L"При подборе сечения Алгоритмом 1 должен быть задан шаг ребер", L" ", MB_OK | MB_ICONERROR);
			  return 1;
			}
			rc_1 = Alg_Weld(0, h0, lambda0, Check_dvutavr, mat_stress, &sect_weld, &mass_1);
			if (rc_1 <= 0)
			   memcpy((char*)&sect_weld1, (char*)&sect_weld, sizeof(SECT_DVUTAVR));
		  }
		  if (ComboBox_Alg->ItemIndex==0 || ComboBox_Alg->ItemIndex==2) {
			rc_2 = Alg_Weld(1, h0, lambda0, Check_dvutavr, mat_stress, &sect_weld, &mass_2);
			if (rc_2 <= 0)
			   memcpy((char*)&sect_weld2, (char*)&sect_weld, sizeof(SECT_DVUTAVR));
		  }
		  if (mass_1 <= mass_2 && rc_1 == 0 || mass_1 <= mass_2 && (rc_1 == -1  && rc_2 == -1)) {
			memcpy((char*)&(sect_weld_plan[i][j]), (char*)&sect_weld1, sizeof(SECT_DVUTAVR));
		  }
		  if (mass_2 < mass_1 && rc_2 == 0 || mass_2 < mass_1 && (rc_1 == -1  && rc_2 == -1)) {
			memcpy((char*)&(sect_weld_plan[i][j]), (char*)&sect_weld2, sizeof(SECT_DVUTAVR));
		  }
		  if (rc_1>0 && rc_2>0) {
			if (rc_2==ERR_ALG2_BEND) {
	 #ifdef EMBRAC
			   i=Application->MessageBox(L"Элемент изгибаемый, алгоритм №2 неприменим", L"",
								  MB_OK | MB_ICONERROR);
	 #else
			   i=Application->MessageBox("Элемент изгибаемый, алгоритм №2 неприменим", "",
								  MB_OK | MB_ICONERROR);
	 #endif
			}
			return 2;
		  }
		}
	  }
	  // Вычисление масс конструктивных элементов и выбор профиля, при котором масса будет минимальна
	  double mass0 = 1e+9;
	  int i0 = -1;
	  int j0 = -1;
	  double Ar, mass_k;
	  for (i = 0; i < Data_select.N_plane; i++) {
		for (j=0; j < Data_select.N_RSU[i]; j++) {
			Ar = sect_weld_plan[i][j].h * sect_weld_plan[i][j].b + sect_weld_plan[i][j].b1 * sect_weld_plan[i][j].h1 +
					   sect_weld_plan[i][j].b2 * sect_weld_plan[i][j].h2;
			mass_k = 0;
			for (k = 0; k < Data_select.N_plane; k++) {
			   mass_k += 7.85e-6*Ar*Data_select.Length[k];
			}
			if (mass0 > mass_k) {
			  i0 = i;
			  j0 = j;
			  mass0 = mass_k;
			}
		}
	  }
	  memcpy((char*)&sect_weld, (char*)&(sect_weld_plan[i0][j0]), sizeof(SECT_DVUTAVR));

	  *mass_prof = mass0;
	  return 0;
}
//--------------------------------------------------------------------------------
// Подбор сечения сварного двутавра на одном участке для одного РСУ одним из алгоритмов
int __fastcall TSelectProfilSectForm::Alg_Weld(int index_prog, double h0, double lambda0, bool *Check_dvutavr, double *mat_stress,
											   SECT_DVUTAVR *sect_weld,	double *mass_prof) {
  double mass0;
  int i,j,k,rc;
  bool flag_fall_mater;
  int rc_check;

		*mass_prof = 1e9;

		sect_weld->b = h0/lambda0;
		sect_weld->h = h0;
		sect_weld->b1 = h0/2;
		sect_weld->h1 = h0/lambda0;
		sect_weld->b2 = h0/2;
		sect_weld->h2 = h0/lambda0;


		sect_weld->n_group = -1;
		sect_weld->n_profil = 0;
		sect_weld->type_profil = 0;
		sect_weld->index_perfor = 0;
		sect_weld->fG = 0;
		sect_weld->tnom = 0;
		sect_weld->b2G = 0;
		sect_weld->gG = 0;
		sect_weld->flag_concl = true;



		switch (index_prog) {
		case 0:
		rc = Dvutavr_Choice_Alg(&Param_chosen_sect, sect_weld, mat_stress, Check_dvutavr,
								RadioGroup_SimmSect->ItemIndex, CheckBox_equWidth->Checked, false);
		break;
		case 1:
		//--------------------------------------------------------------------------------------
		// Альтернативный вариант
		rc = ChoiсeKolonna_Alg(&Param_chosen_sect, sect_weld,
							   Data_select.length_XZ[0], Data_select.length_XY[0], mat_stress, true);
		break;

		default:
			;
		}
		if (rc!=0) {
		   return rc;
		}
		// Контроль кода завершения
		//Dvutavr_OutControl(rc);
		//----------------------------------------------------------------------------------------------
		// Выполнить предварительную проверку сварного двутавра
		// Выполнить проверку для профиля минимальной массы n_profil с числом толщин n_thick, чтобы получить критерии
		for (k = 0; k < 20; k++) {
		  rc = Check_profil(0, 0, &flag_fall_mater);
		  if (rc > 0)
			 rc_check = rc;
		  if (CheckBox_Draft->Checked) break;
		  if (Krit[1][1] > 1.0 || Krit[2][6] > 1.0 ) { // Прочность на сжатие
			 sect_weld->h1 += 0.5;
			 sect_weld->h2 += 0.5;
			 sect_weld->h1 = Round_row(sect_weld->h1, RadioGroup_sort->ItemIndex);
			 sect_weld->h2 = Round_row(sect_weld->h2, RadioGroup_sort->ItemIndex);
			 continue;
		  }
		  if (Krit[1][3] > 1.0 || Krit[2][13] > 1.0 || Krit[2][14] > 1.0) {
			sect_weld->b += 0.5;
			sect_weld->b = Round_row(sect_weld->b, RadioGroup_sort->ItemIndex);
			continue;
		  }
		  if ( Krit[2][17] > 1.0) {
			if (sect_weld->b1 == sect_weld->b2) {
			   sect_weld->b1 += 5;
			   sect_weld->b2 += 5;
			}
			else {
			  if (sect_weld->b1 < sect_weld->b2)
				sect_weld->b1 += 5;
			  else
				sect_weld->b2 += 5;
			}
			continue;
		  }
		  break;
		}

		mass0 = 0;
		double Ar = sect_weld->h * sect_weld->b + sect_weld->b1 * sect_weld->h1 + sect_weld->b2 * sect_weld->h2;

		for (j=0; j<Data_select.N_plane; j++) {
		  mass0 += 7.85e-6*Ar*Data_select.Length[j];
		}
		*mass_prof = mass0;
		if (k==20) {
		   return -1;   // Условия прочности не выполнены
		}
		else
		   return 0;

}
//---------------------------------------------------
// Выполнить проверку для профиля num
// Возвращает 0, если проверка прошла; 1 - если проверка не прошла
int __fastcall TSelectProfilSectForm::Check_profil(int num_profil, int num_thick, bool *flag_fall_thick) {

	int i, j, k, m, rc;
	//
	DATA_CHECK_U data_check;
	int n_krit;
	int nnel_krit[100];   // Номер элемента (участка), на котором критерий максимален
	double krit_[100];
	int number_profil;
	int iW;
	int Index_nf;
	int Vid_soedineniya;

	CheckExecute.NumNameGroup[0] = 0;
	CheckExecute.NelemInGroup[0] = 0;
	TabSheet_WeldCheck->TabVisible = false;

	switch (Data_select.form_profil) {
	case DVUTAVR_STAND:
	case PERFOR_BEAM:
	// Заполнить структуру параметров сечения двутавра по его номеру
	  rc =  StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), num_profil);
	  if (rc>0) return rc;
	  CheckExecute.Sect_Elem_Group[0].type_sect = DVUTAVR;
	  Index_nf = -1;  // Нет швов
	  Vid_soedineniya = -1;
	break;
	case TRUBA:
	  number_profil = StandartProfil.GetNumberProfil_Tube(num_profil, num_thick);

	  rc = StandartProfil.SetParamProfil_Tube(&(CheckExecute.Sect_Elem_Group[0].com_sect), Data_select.type_profil, number_profil, 0);
	  if (rc>0) return rc;

	  switch (Data_select.type_profil) {
	  case typeSQUARE:
		CheckExecute.Sect_Elem_Group[0].type_sect = SQUARE_TUBE;
	  break;
	  case typeRECT:
		CheckExecute.Sect_Elem_Group[0].type_sect = RECT_TUBE;
	  break;
	  case typeCIRC:
		CheckExecute.Sect_Elem_Group[0].type_sect = CIRCULAR_TUBE;
	  break;
	  }
	  Index_nf = -1;  // Нет швов
	  Vid_soedineniya = -1;
	break;
	case DVUTAVR_WELD:
	// Заполнить структуру параметров сечения двутавра по его номеру
	  memcpy(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), &sect_weld, sizeof(SECT_DVUTAVR));
	  CheckExecute.Sect_Elem_Group[0].type_sect = DVUTAVR;
	  if (Data_select.kf_comp <=0) {
		 rc = Application->MessageBox(L"Не задан катет сварных швов", L" ", MB_OK | MB_ICONERROR);
		 PageControl_Data->ActivePage = TabSheet_Weld;
		 return rc;
	  }
	  Index_nf = 1;  // Двусторонний шов
	  Vid_soedineniya = 0;
	  TabSheet_WeldCheck->TabVisible = true;
	break;
	case COMPOSED_BEAM:  // Двутавр
	   switch (Data_select.index_composed) {
	   case TAVR_PLATE_DOWN:
	   case TAVR_PLATE_UP:
		 rc =  StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), num_profil);
		 if (rc>0) return rc;
		 CheckExecute.Sect_Elem_Group[0].type_sect = TAVR;
		 Index_nf = 1;  // Двусторонний шов
		 Vid_soedineniya = 0;
	   break;
	   case DVUTAVR_PLATE_DOWN:
	// Заполнить структуру параметров сечения двутавра по его номеру
		 rc =  StandartProfil.SetParamProfil(&(CheckExecute.Sect_Elem_Group[0].com_sect.dvutavr), num_profil);
		 if (rc>0) return rc;
		 CheckExecute.Sect_Elem_Group[0].type_sect = DVUTAVR;
		 Index_nf = 0;  // Односторонний шов
		 Vid_soedineniya = 1;
	   break;
	   }
	   if (Data_select.kf_comp <=0) {
		 rc = Application->MessageBox(L"Не задан катет сварных швов", L" ", MB_OK | MB_ICONERROR);
		 PageControl_Data->ActivePage = TabSheet_sect_comp;
		 return rc;
	   }
	   TabSheet_WeldCheck->TabVisible = true;
	break;
	}
	// Записать параметры последнего проверенного сечения
	memcpy((char*)&Last_com_sect, (char*)&(CheckExecute.Sect_Elem_Group[0].com_sect), sizeof(COMMON_SECT));
	Last_type_sect = CheckExecute.Sect_Elem_Group[0].type_sect;

	// Вычисление параметров сечения - нужна площадь сечения
	GEOM_PARAM_SECT param_sect;
	if (Data_select.form_profil==COMPOSED_BEAM) {
	  Get_param_sect_composed(CheckExecute.Sect_Elem_Group[0].type_sect, &(CheckExecute.Sect_Elem_Group[0].com_sect),
							  Data_select.plate_width, Data_select.plate_thick, &param_sect, Data_select.index_composed);
	}
	else {
	  Get_param_sect_comm(CheckExecute.Sect_Elem_Group[0].type_sect, &(CheckExecute.Sect_Elem_Group[0].com_sect), &param_sect);
	}
	double FRo_curr = param_sect.Ar*7850*1e-6;

	double Izz_RSU = BalkaLoadFrame1->Izz_RSU;   // Для справки
	//----------------------------------------------------------------------------------
	// Заполнение РСУ и соответствующих номеров элементов (участков)
	int n_rsu = 0;

		  // Вычисление максимального прогиба
	if (Data_select.index_loads==1) {   // Воздействие задано в форме загружений
		Data_select.MaxV = (Data_select.MaxV0 + Data_select.MaxV_W*(FRo_curr/Data_select.FRo_RSU - 1))*Data_select.Izz_RSU/param_sect.Izz;
	 }
	 else {
		Data_select.MaxV = 0;
	 }

	for (i = 0; i < Data_select.N_plane; i++) {
	  for (j=0; j < Data_select.N_RSU[i]; j++) {
		if (Data_select.q_bal[i][j] == 0) {
		  CheckExecute.ListElem_RSU[n_rsu] = i;
		  CheckExecute.Elem_RSU[n_rsu][0] = Data_select.RSU[i][j][0]*Data_select.gamma_n;     // N
		  CheckExecute.Elem_RSU[n_rsu][1] = 0;
		  CheckExecute.Elem_RSU[n_rsu][2] = Data_select.RSU[i][j][1]*Data_select.gamma_n;    // Mx
		  CheckExecute.Elem_RSU[n_rsu][3] = Data_select.RSU[i][j][2]*Data_select.gamma_n;    // Qy
		  CheckExecute.Elem_RSU[n_rsu][4] = Data_select.RSU[i][j][3]*Data_select.gamma_n;    // My
		  CheckExecute.Elem_RSU[n_rsu][5] = Data_select.RSU[i][j][4]*Data_select.gamma_n;    // Qx
		  CheckExecute.q_bal_n[n_rsu][0] = CheckExecute.q_bal_n[n_rsu][1] = 0;    // qy
		  CheckExecute.q_bal_r[n_rsu][0] = CheckExecute.q_bal_r[n_rsu][1] = 0;    // qy
		  if (Data_select.index_loads==1) {  // Воздействие задано в форме загружений
			CheckExecute.Elem_RSU[n_rsu][0] += Data_select.RSU_W[j][0]*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
			CheckExecute.Elem_RSU[n_rsu][2] += Data_select.RSU_W[j][1]*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
			CheckExecute.Elem_RSU[n_rsu][3] += Data_select.RSU_W[j][2]*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
			CheckExecute.Elem_RSU[n_rsu][4] += Data_select.RSU_W[j][3]*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
			CheckExecute.Elem_RSU[n_rsu][5] += Data_select.RSU_W[j][4]*Data_select.gamma_n*(FRo_curr/Data_select.FRo_RSU - 1);
		  }
		  n_rsu++;
		}
		else {
		  CheckExecute.ListElem_RSU[n_rsu] = i;
		  CheckExecute.Elem_RSU[n_rsu][0] = Data_select.RSU[i][j][0]*Data_select.gamma_n;     // N
		  CheckExecute.Elem_RSU[n_rsu][1] = 0;
		  CheckExecute.Elem_RSU[n_rsu][2] = Data_select.RSU[i][j][1]*Data_select.gamma_n -
											Data_select.q_bal[i][j]*Data_select.Length[i]*Data_select.Length[i]*Data_select.gamma_n*1e-6/8 ;    // Mx
		  CheckExecute.Elem_RSU[n_rsu][3] = Data_select.RSU[i][j][2]*Data_select.gamma_n;    // Qy
		  CheckExecute.Elem_RSU[n_rsu][4] = Data_select.RSU[i][j][3]*Data_select.gamma_n;    // My
		  CheckExecute.Elem_RSU[n_rsu][5] = Data_select.RSU[i][j][4]*Data_select.gamma_n;    // Qx
		  // Значения нормативной распределенной нагрузки qy на балке)
		  CheckExecute.q_bal_n[n_rsu][0] = CheckExecute.q_bal_n[n_rsu][1] = Data_select.Krn*Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
		  CheckExecute.q_bal_r[n_rsu][0] = CheckExecute.q_bal_r[n_rsu][1] = Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
		  n_rsu++;
		  CheckExecute.ListElem_RSU[n_rsu] = i;
		  CheckExecute.Elem_RSU[n_rsu][0] = Data_select.RSU[i][j][0]*Data_select.gamma_n;     // N
		  CheckExecute.Elem_RSU[n_rsu][1] = 0;
		  CheckExecute.Elem_RSU[n_rsu][2] = Data_select.RSU[i][j][1]*Data_select.gamma_n;     // Mx
		  CheckExecute.Elem_RSU[n_rsu][3] = Data_select.RSU[i][j][2]*Data_select.gamma_n -
											Data_select.q_bal[i][j]*Data_select.Length[i]*Data_select.gamma_n*1e-3/2 ; // Qy
		  CheckExecute.Elem_RSU[n_rsu][4] = Data_select.RSU[i][j][3]*Data_select.gamma_n;    // My
		  CheckExecute.Elem_RSU[n_rsu][5] = Data_select.RSU[i][j][4]*Data_select.gamma_n;    // Qx
		  // Значения нормативной распределенной нагрузки qy на балке)
		  CheckExecute.q_bal_n[n_rsu][0] = CheckExecute.q_bal_n[n_rsu][1] = Data_select.Krn*Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
		  CheckExecute.q_bal_r[n_rsu][0] = CheckExecute.q_bal_r[n_rsu][1] = Data_select.q_bal[i][j]*Data_select.gamma_n;    // qy
		  n_rsu++;
		}
	  }

	}
	CheckExecute.NRSU = n_rsu;

	memcpy((char*)&CheckExecute.MaterPropU_prof, (char*)&Data_select.MaterProp_prof, sizeof(MATER));
	// Присоединение префикса к имени материала
	AnsiString Astr = (AnsiString)Data_select.MaterProp_prof.title + Prefix;
	strcpy(CheckExecute.MaterPropU_prof.title, Astr.c_str());

	data_check.flag_same_material = Data_select.index_same_material;
	if (!data_check.flag_same_material) { // Материал профиля и пластины одинаковый
	  memcpy((char*)&CheckExecute.MaterPropU_plate, (char*)&CheckExecute.MaterPropU_prof, sizeof(MATER));
	}
	else {
	  memcpy((char*)&CheckExecute.MaterPropU_plate, (char*)&Data_select.MaterProp_plate, sizeof(MATER));
	// Присоединение префикса к имени материала пластины
	  AnsiString Astr = (AnsiString)Data_select.MaterProp_plate.title + Prefix_plate;
	  strcpy(CheckExecute.MaterPropU_plate.title, Astr.c_str());
	}
	data_check.IRels = 0;


	if  (Data_select.koeff_length_XZ[0]==0 || Data_select.koeff_length_XY[0]==0 ) {
		rc = Application->MessageBox(L"Проверки не выполняются, т.к. РСУ не получены.", L"",
								  MB_OK | MB_ICONERROR);
        return rc;
    }
	// Заполнение структуры data_check
	for (i=0; i<Data_select.N_plane; i++) {
	  data_check.length[i] = Data_select.Length[i];
	  data_check.length_XZ[i] = Data_select.Length[i]*Data_select.koeff_length_XZ[i];   // В плоскости поясов
	  data_check.length_YZ[i] = Data_select.Length[i]*Data_select.koeff_length_XY[i];
	  if (Data_select.index_loads == 0) {   // Воздействие задано в форме РСУ
		data_check.step_ext[i] = Data_select.step_comp[i];
		data_check.step_int[i] = Data_select.step_comp[i];
	  }
	  else {
		data_check.step_ext[i] = Data_select.step_up;
		data_check.step_int[i] = Data_select.step_down;
	  }
	}
	//data_check.index_type = Data_select.index_type; // Тип нагружения констр. элемента (центрально-рвстянутый, и.т.п
	data_check.gamma_c = Data_select.gamma_c;
	data_check.gamma_n = Data_select.gamma_n;
	data_check.Limit_lambda1 = Data_select.Limit_lambda1;
	data_check.Limit_lambda2 = Data_select.Limit_lambda2;
	data_check.Limit_lambda_plus = Data_select.Limit_lambda_plus;
	data_check.index_otvetstv = Data_select.index_otvetstv;
	data_check.index_class = Data_select.index_class;
	data_check.index_group = Data_select.index_group;
	data_check.koeff_material_nadeghn = Data_select.gamma_m;

	data_check.strela = Data_select.Strela;
	data_check.delta_lim = Data_select.Delta_lim;

	data_check.edge_step = Data_select.Step_edge;
	data_check.edge_thick = 10;

	data_check.edge_width = 100;
	data_check.flag_cont_int = false;
	data_check.flag_cont_ext = false;
	data_check.flag_dynamic_load = false;
	data_check.type_edge = Data_select.index_1_or_2;
	data_check.index_local = 0;
	data_check.index_nf = Index_nf;     // нет швов (-1), односторонний (0), двусторонний (1) или шов с проваром на всю глубину (2)
	data_check.index_vid_soedineniya = Vid_soedineniya;
	data_check.index_vid_svarki = 0;
	data_check.q_down_max = Data_select.q_down_max;
	data_check.q_down_LR_max = Data_select.q_down_LR_max;
	data_check.M_down_LR_max = Data_select.M_down_LR_max;
	memcpy(&(data_check.Weld_param_stenka), &(Weld_balka_unit), sizeof(WELD_PARAM));
	memcpy(&(data_check.Weld_param_polka), &(Weld_balka_unit), sizeof(WELD_PARAM));
	data_check.kf = Data_select.kf_comp;
	data_check.ugol_var = 0.0;
	data_check.Local_F_ = 0;  // Местная нагрузка
	data_check.index_place_local = 0;   // Приложение местной нагрузки к внешнему поясу
	data_check.Local_b_ = 0;
	data_check.span = Data_select.Span;
	data_check.del_max = Data_select.MaxV;
	data_check.fi_b_type_constr = Data_select.index_constr;  // тип закрепления 0 - пролет, 1 - консоль
	data_check.fi_b_num_constr = Data_select.index_G1_count;   // количество закреплений в пролете 0 - без закреплений, 1 - два в середине 2 - одно в середине
	data_check.fi_b_type_load = Data_select.index_G1_load;   // тип нагрузки 0 - сосредоточенная в середине, 2 - равномерно распределенная; 3 - любая; 2 - сосредоточенная на четверти
	if (Data_select.form_profil==COMPOSED_BEAM)
	  data_check.fi_b_index_poyas = 1; // 0 - нагрузка приложена к сжатому поясу, 1 - к растянутому
	else
	  data_check.fi_b_index_poyas = 0; // 0 - нагрузка приложена к сжатому поясу, 1 - к растянутому
	data_check.sigma_minus = -0.5;     // если напряжение больше , то элемент не сжат
	data_check.sigma_plus = 0.5;      // если напряжение меьше , то элемент не растянут
	data_check.N_minus = -0.5e-1;        // в кН
	data_check.N_plus = 0.5e-1;
	data_check.M_max_i = 0.5e-4;
	data_check.M_third = 0;
	data_check.flag_vary_sten = false;
	data_check.flag_step_edge = Data_select.index_edge;
	data_check.flag_razrez = Data_select.index_razrez;
	data_check.q_ext = 0;      // распределенная нагрузка, приложенная к наружному поясу
	data_check.flag_perfor = false;
	data_check.flag_composed = false;
	data_check.index_composed = -1;
	data_check.flag_netto = false;
	if (Data_select.index_loads==0 || Data_select.index_loads==2) {    // Воздействие задано в форме РСУ, либо получено из модели стойки
	   data_check.flag_bending = false;
	}
	else {
	   data_check.flag_bending = true;
	}
	if (Data_select.form_profil ==PERFOR_BEAM) {
	   data_check.flag_perfor = true;
	   data_check.perfor_attit = Data_select.perfor_attit;
	   data_check.perfor_alfa = Data_select.perfor_alfa;
	}
	if (Data_select.form_profil ==COMPOSED_BEAM) {
	   data_check.flag_composed = true;
	   data_check.index_composed = Data_select.index_composed;
	   data_check.plate_width = Data_select.plate_width;
	   data_check.plate_thick = Data_select.plate_thick;
	}
	data_check.index_Qy = Data_select.index_Qy;

	//----------------------------------------------------------------------------------
   //---------------------------------------------------------------------------------------
   // Определение типов проверок для каждого элемента
	rc = CheckExecute.SetConditionCheck(&data_check, flag_check);
	if (rc>0) {
	  if (rc == steel_T_LESS || rc == steel_T_UPPER ) {
		*flag_fall_thick = true;
	  }
	  return rc;
	}
	//-------------------------------------------------------------------------
	// Проверить соответствие класса разрезности и Ry материала
	STEEL_PARAM steel_param;

	rc = Steel_param(MaterProp[Material_Number].title, 10.0, &(steel_param), false);

	if (Data_select.index_class > 1 && Data_select.index_razrez==0) {
	  if (!flag_warning_razrez) {
		rc=Application->MessageBox((L"Для неразрезной балки задан класс элементов конструкции по НДС \"" + IntToStr(Data_select.index_class) +
								 "\". \nРасчет будет выполняться в предположении упругой работы стали.").c_str(), L"Противоречивые условия",
								  MB_OK | MB_ICONWARNING);
		flag_warning_razrez = true;
	  }
	}
	if (Data_select.index_class > 1 && steel_param.Ryn > 440 ) {
		 if (!flag_warning_steel) {
		   rc=Application->MessageBox((L"Для стали с Ryn > 440 МПа задан класс элементов конструкции по НДС " + IntToStr(Data_select.index_class) +
								 ". \nРасчет будет выполняться в предположении упругой работы стали.").c_str(), L"Противоречивые условия",
								  MB_OK | MB_ICONWARNING);
		   flag_warning_steel = true;
		 }
	}

   // Цикл по типам проверок
	for (j=0; j<NUMBER_CHECK; j++) {
	  if (!flag_check[j])  // означает, что данный тип проверки не нужно выполнять
		continue;
	  data_check.index_type = j;  // Здесь j совпадает со значениями
	 // #define CENTR_TENSION       0
	 // #define CENTR_COMPRESSION   1
	 // #define COMPRESSION_BENDING 2
	 // #define BENDING             3
	 // #define TENSION_BENDING     4

		// Здесь нужно установить реальное количество проверок
	  data_check.num_krit = Data_select.N_check[j];   // Количество проверок
		// Здесь нужно установить реальные флаги проверок
	  for (i=0; i<Data_select.N_check[j]; i++)
	  {
		   if (Num_prov[j][i]==1)                                         //Num_prov[j][9]
			  data_check.Checked[i] = true;  // флаги проверок
		   else
			  data_check.Checked[i] = false;  // флаги проверок
	  }

	  CheckExecute.RichEdit_Weld = RichEdit_KI_Weld;
	  CheckExecute.Count_Weld = Data_select.N_check_weld;
	  for (i=0; i<Data_select.N_check_weld; i++)
	   if (Num_prov_weld[i] == 1)
		  CheckExecute.Checked_weld[i] = true;
	   else
		  CheckExecute.Checked_weld[i] = false;

	  switch (Data_select.form_profil) {
	  // Выполнение проверок для двутавра
	  case DVUTAVR_STAND:
	  case DVUTAVR_WELD:
	  case PERFOR_BEAM:
	  case COMPOSED_BEAM:
		rc = CheckExecute.CheckExecuteU(&data_check, &n_krit, krit_, nnel_krit);
	  break;
	  case TRUBA:                             // Выполнение проверок для трубы
		rc = CheckExecute.CheckExecuteU_Tube(&data_check, &n_krit, krit_, nnel_krit);
	  break;
	  }
	  if (krit_[0]==101) { // 101 означает, что не задан шаг раскрепления
		return 101;
	  }
	  if (krit_[0]==100) { // 100 означает, что толщины профиля нарушают ограничения по материалу
		*flag_fall_thick = true;
	  }
	  else {
		*flag_fall_thick = false;
	  }
	  for (i=0; i<data_check.num_krit; i++) {
		Krit[j][i] = krit_[i];
		Nnel_Krit[j][i] = nnel_krit[i];
	  }	   //Krit[1][1]
	  for (i=0; i<data_check.num_krit; i++) {
		 if (Round(krit_[i], 2) > 1.0)
			return 1;
	  }
	}


	return 0;

}
//------------------------------------------
// получить параметры плиты и минимального шва
void Get_plate_param(int index_composed, COMMON_SECT *com_sect, double *plate_width, double *plate_thick, double *kf_comp) {
	int rc;
	switch (index_composed) {
	case 0:
		*plate_width = Round_step(com_sect->tavr.b1 + 190, 10);
		*plate_thick = Round_step(com_sect->tavr.h1*0.65, 5);
		//*kf_comp = Round_step_floor(1.2*(MIN(com_sect->tavr.b, *plate_thick)), 1);
		*kf_comp = Get_min_kf_new(2, 0, 0, com_sect->tavr.b, *plate_thick, &rc);
	break;
	case 1:
		*plate_width = Round_step(com_sect->tavr.b1 - 200, 10);
		*plate_thick = Round_step(com_sect->dvutavr.h1*1.7, 5);
		//*kf_comp = Round_step_floor(1.2*(MIN(com_sect->tavr.b, *plate_thick)), 1);
		*kf_comp = Get_min_kf_new(2, 0, 0, com_sect->tavr.b, *plate_thick, &rc);
	break;
	case 2:
		*plate_width = Round_step(com_sect->tavr.b2 + 190, 10);
		*plate_thick = Round_step(com_sect->dvutavr.h2*0.8, 5);
		//*kf_comp = Round_step_floor(1.2*(MIN(com_sect->tavr.h2, *plate_thick)), 1);
		*kf_comp = Get_min_kf_new(2, 0, 0, com_sect->tavr.h2, *plate_thick, &rc);
	break;
	}
    return;
}

