//-----------------------------------------------------------------------------------------
// Выполнение проверок для труб прямоугольного сечения
int TCheckExecute::CheckExecuteU_Tube(DATA_CHECK_U *data_check, int *n_krit, double *krit, int *nnel_krit)
{
   double Ry, Rs, Ey;
   int i, rc;
   int ngroup, Nelem; // число элементов группы
   GEOM_PARAM_SECT param_sect;
   GEOM_PARAM_SECT param_netto;
   STEEL_PARAM steel_param;
   double i_zz, i_yy;
   double lambdaX[100], lambdaY[100];   // гибкости в плоскостях XZ и YZ
   double lambda_x[100], lambda_y[100]; // условные гибкости
   double lambda_w; // условная гибкость стенки в пл. XZ
   double lambda_wY; // условная гибкость стенки
   double lambda_f; // условная гибкость стенки в пл. XY
   double lambda_uw[100], lambda_uf[100]; // наибольшая условная гибкость стеноки
   double h_, t_, hef;
   double bef_1, bef_2, tef_1, tef_2;
   double fi_x[100], fi_y[100];
   //double lambda_f1, lambda_f2;
   double N_, Q_, Q_y, M_, M_y;
   int type_sect;
   double Ru;
   double gamma_m;
   double sigma_comm[6]; // напряжение в угловых точках 0, 1 - верхний пояс, 1, 2 - нижний пояс
   double Forces[8];
   double Aw, Af;
   double b_, bef;
   // Условные гибкости поясов в плоскости поясов
   double lambda_f1Y[100], lambda_f2Y[100];
   // Гибкости поясов в плоскости поясов
   double Lambda_f1Y[100], Lambda_f2Y[100];
   double WcY, WtY, AfY, AwY;
   double Wx_min, Wy_min; // момент сопротивления, соответствующий более сжатому и растянутому поясу
   double Wc, Wt; // момент сопротивления, соответствующий более сжатому и растянутому поясу
   COMMON_SECT  section_tube;
   int n_elem, n_elem_rep;
   MATER_PARAM mater_param;
   double Ad[100], hd, bd;


   for (i=0; i<30; i++) {   // Предварительное зануление
		krit[i] = -1;
		nnel_krit[i] = -1;
   }
 // номер группы проверки
   ngroup = NumNameGroup[0];
   Nelem = NelemInGroup[ngroup];
   // Максимальная толщина стенки (толщина у всех сечений идет первой в структуре)
   type_sect = Sect_Elem_Group[ngroup].type_sect;
   double t_max = Get_thick_sect(type_sect, &(Sect_Elem_Group[ngroup].com_sect));
   thick_prof = t_max;
   //  Получить таблицу свойств стали по марке стали и проверить границы толщин
   rc = Get_Mater_param(MaterPropU_prof.title, &mater_param);
   if (rc>0) return rc;
   // Переменные класса
   strcpy(Msteel_prof, MaterPropU_prof.title);
   thick_prof = t_max;
   thick_range_material[0] = mater_param.thick_row[0];
   thick_range_material[1] = mater_param.thick_row[mater_param.n_row];
   //----------------------------------------------

   if (t_max > mater_param.thick_row[mater_param.n_row] || t_max <  mater_param.thick_row[0]) {
	 krit[0] = 100;
	 *n_krit = 1;
	 return 0;
   }

   // Получить диапазон толщин
   double thick_range[2];
   rc = Get_thick_range(MaterPropU_prof.title, t_max, thick_range);
   SelectProfilSectForm->Data_select.t0 = thick_range[0];
   SelectProfilSectForm->Data_select.t1 = thick_range[1];

	// Расчетное сопротивление растяжению, сжатию и изгибу по пределу текучески
   Ry = Steel_param_Ry(MaterPropU_prof.title, t_max, &rc, true);
	// Расчетное сопротивление растяжению, сжатию и изгибу по пределу текучески
   SelectProfilSectForm->Data_select.Ry = Ry;
   SelectProfilSectForm->Data_select.Run = Steel_param_Run(MaterPropU_prof.title, t_max, &rc, false);

   Ey = MaterPropU_prof.E;

   Rs = 0.58*Ry;

   gamma_m = MaterPropU_prof.gamma_m;           // Коэффициент надежности по материалу
   rc = Steel_param(MaterPropU_prof.title, t_max, &(steel_param), false);
   if (rc>0)
	 return rc;
   Ru = steel_param.Ru;             // Временное сопротивление по растяжению, сжатию и изгибу

   //
   if (type_sect == SQUARE_TUBE) {
	 section_tube.rect.b = Sect_Elem_Group[ngroup].com_sect.square.side;
	 section_tube.rect.h = Sect_Elem_Group[ngroup].com_sect.square.side;
	 section_tube.rect.b1 = Sect_Elem_Group[ngroup].com_sect.square.thickness;
	 section_tube.rect.h1 = Sect_Elem_Group[ngroup].com_sect.square.thickness;
	 section_tube.rect.n_group = Sect_Elem_Group[ngroup].com_sect.square.n_group;
	 section_tube.rect.n_profil = Sect_Elem_Group[ngroup].com_sect.square.n_profil;
	 section_tube.rect.flag_concl = Sect_Elem_Group[ngroup].com_sect.square.flag_concl;
   }
   else {
	 memcpy((char*)&section_tube, (char*)&Sect_Elem_Group[ngroup].com_sect, sizeof(COMMON_SECT));
   }
   //
   // Вычислить геометрические характеристики сечения группы
   Get_param_sect_comm(type_sect, &(Sect_Elem_Group[ngroup].com_sect), &param_sect);
   // param_netto = param_sect
   memcpy((char*)&param_netto, (char*)&param_sect, sizeof(GEOM_PARAM_SECT));

   Wc = param_sect.Izz/param_sect.Zct;
   Wt = Wc;
   WcY = param_sect.Iyy/param_sect.Yct;
   WtY = WcY;

   Wx_min = MIN(param_netto.Izz/param_netto.Zct, param_netto.Izz/(param_netto.Hsect - param_netto.Zct));
   Wy_min = MIN(param_netto.Iyy/param_netto.Yct, param_netto.Iyy/(param_netto.Wsect - param_netto.Yct));

   i_zz = sqrt(param_sect.Izz/param_sect.Ar);
   i_yy = sqrt(param_sect.Iyy/param_sect.Ar);
   for (i=0; i<NRSU; i++) {
	 n_elem = ListElem_RSU[i];
   // Гибкость элемента
	 lambdaX[n_elem] = data_check->length_XZ[n_elem]/i_zz;
	 lambdaY[n_elem] = data_check->length_YZ[n_elem]/i_yy;
   // Условная гибкость элемента
	 lambda_x[n_elem] = lambdaX[n_elem]*sqrt(Ry/Ey);     // в плоскости стенки
	 lambda_y[n_elem] = lambdaY[n_elem]*sqrt(Ry/Ey);     // в плоскости поясов

   // Вычисление fi_y - коэффициент устойчивости в плоскости поясов при центальном сжатии
	 fi_y[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[ngroup].type_sect, lambda_y[n_elem], 1), 3);
	 fi_y[n_elem] = MAX(0.001, fi_y[n_elem]);
   // Вычисление fi_x коэффициент устойчивости в плоскости стенки при центальном сжатии
	 fi_x[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[ngroup].type_sect, lambda_x[n_elem], 0), 3);
	 fi_x[n_elem] = MAX(0.001, fi_x[n_elem]);

   // Значение условной предельной гибкости стенки при центальном сжатии
	 double lambda_r = MAX(lambda_x[n_elem], lambda_y[n_elem]);
	 lambda_uw[n_elem] = Fun_lambda_uw_cent(Sect_Elem_Group[ngroup].type_sect, lambda_r);
   // Значение условной предельной гибкости в плоскости поясов при центральном сжатии
	 lambda_uf[n_elem] = Fun_lambda_uf_cent(Sect_Elem_Group[ngroup].type_sect, lambda_r);
	 if (type_sect == SQUARE_TUBE || type_sect == RECT_TUBE) {
	 // Высота стенки и расчетная высота стенки в плоскости момента M_
	   h_ = section_tube.rect.h; // - 2*section_tube.rect.h1;
	   hef = h_ - 2*param_sect.Rad;

	 // Высота стенки и расчетная высота стенки в плоскости момента M_y
	   b_ = section_tube.rect.b; // - 2*section_tube.rect.h1;
	   bef = b_ - 2*param_sect.Rad;

	   t_ = section_tube.rect.h1;
	   bef_1 = section_tube.rect.b;
	   tef_1 = section_tube.rect.b1;
	   bef_2 = bef_1;
	   tef_2 = tef_1;
	   Af = bef_1*tef_1;   // площадь пояса для плоскости XZ
	   Aw = t_*h_;         // Площадь одной стенки
	   AfY = section_tube.rect.b*tef_1;   // площадь пояса для плоскости XY
	   AwY = t_*b_;

	 // Условные гибкости стенок
	   lambda_w = (hef/t_)*sqrt(Ry/Ey);                     // В пл. XZ
	   lambda_f = lambda_wY = (bef/t_)*sqrt(Ry/Ey);         // В пл. XY
   // Условные гибкости свеса поясов
	   //lambda_f1 = (((bef_1 - t_)*0.5 - param_sect.Rad)/tef_1)*sqrt(Ry/Ey);
	   //lambda_f2 = (((bef_2 - t_)*0.5 - param_sect.Rad)/tef_2)*sqrt(Ry/Ey);
   // Гибкости поясов в плоскости поясов
	   Lambda_f1Y[n_elem] = (data_check->step_ext[n_elem]*3.4641/bef_1);    // 3.4641 = sqrt(12)
	   Lambda_f2Y[n_elem] = (data_check->step_int[n_elem]*3.4641/bef_2);
	 // Условные гибкости поясов в плоскости поясов
	   lambda_f1Y[n_elem] = Lambda_f1Y[n_elem]*sqrt(Ry/Ey);
	   lambda_f2Y[n_elem] = Lambda_f2Y[n_elem]*sqrt(Ry/Ey);
   // Условные гибкости стенки и поясов
   // Вычисление редуцированной площади сечения
	   if (lambda_w/lambda_uw[n_elem] <=1.0 && lambda_f/lambda_uf[n_elem] <= 1.0)
		  Ad[n_elem] = param_sect.Ar;
	   else {
		  double h0_ = section_tube.rect.h - 2*section_tube.rect.h1;
		  hef = h0_ - 2*param_sect.Rad;
		  double t_ = section_tube.rect.h1;
		  hd = t_*(lambda_uw[n_elem] - (lambda_w/lambda_uw[n_elem] - 1)*(lambda_uw[n_elem] - 2.9 - 0.2*(MIN(lambda_x[n_elem], 2.3)) - 0.7*lambda_w))*sqrt(Ey/Ry);
		  hd = MIN(hd, h0_);
		  bd = tef_1*(lambda_uf[n_elem] - (lambda_f/lambda_uf[n_elem] - 1)*(lambda_uf[n_elem] - 2.9 - 0.2*(MIN(lambda_x[n_elem], 2.3)) - 0.7*lambda_f))*sqrt(Ey/Ry);
		  bd = MIN(bd, section_tube.rect.b);

		  Ad[n_elem] = param_sect.Ar - 2*(h_ - hd)*t_ - 2*(b_ - bd)*tef_1;        // ф. 32
	   }
	 }
	 else {
	   //lambda_f1 = lambda_f2 = 1; // формально
	   h_ = section_tube.circ.diameter; // формально
	   b_ = section_tube.circ.diameter; // формально
	   hef = section_tube.circ.diameter; // формально
	   bef = section_tube.circ.diameter; // формально
	   t_ = section_tube.circ.thickness;
	   Af = hef*t_;              // формально
	   Aw = bef*t_;;             // формально
	   bef_1 = section_tube.circ.diameter; // формально
	   tef_1 = section_tube.circ.diameter; // формально
	   bef_2 = bef_1;
	   tef_2 = tef_1;
       Ad[n_elem] = param_sect.Ar;
	 }
   }
   //--------------------------------------------------------------------------
   // Центрально-растянутые
   // в nnel_krit[i] содержатся номера элементов, в которых достигается максимум по i-му критерию
   if (data_check->index_type == CENTR_TENSION) {
	  CHECK_ELEM_PARAM_U *Cp;
	  double Nmax = 0;
	  double k_, lambda_u;

	  Cp = &(Check_param);
	  // Зануление критериев
	  for (i=0; i<data_check->num_krit; i++) {
		krit[i] = -1;
		nnel_krit[i] = -1;
	  }
	  double krit_tens_max = 0;
	  int RSU_tens_max;
	  for (i=0; i<NRSU; i++) {
		n_elem = ListElem_RSU[i];
		if (!CheckElem[i][0])
		  continue;
		n_elem_rep = n_elem;
		N_ = Elem_RSU[i][0]*1000;

		//sigma_beam_comm(&param_sect, Forces, sigma_comm);
		// 1. ------------------------------------------------------
		if (data_check->Checked[0]) {
		  double Ryn;
		// Расчет на прочность, п.7.1.1. ф.(5)
		  if (steel_param.Ryn <= 440)
			Ryn = Ry;
		  else
			Ryn = steel_param.Ru/data_check->koeff_material_nadeghn;
		  //krit[0] = MAX(krit[0], (ABS(N_))/(param_netto.Ar*Ryn*data_check->gamma_c));
		  double krit_0 = (ABS(N_))/(param_netto.Ar*Ryn*data_check->gamma_c);
		  if (krit_0 > krit[0]) {
			 Cp->NT_ = N_;
			 Cp->Ry = Ryn;
		  }
		  MAXNNEL(krit[0], krit_0, 0);
		  //if (krit_0 > 1.05)
		  //	return 0;
		  if (krit[0] > krit_tens_max) {
			krit_tens_max = krit[0];
			RSU_tens_max = n_elem;
		  }
		}
 		// Определение коэффициента k_ в сответствии с п. 10.4.2
		if ((data_check->index_otvetstv == 0 || data_check->index_otvetstv == 1) &&
			   data_check->index_group < 3)
			k_=1;
		else
			k_=1.1;
		if (data_check->Checked[1]) {
		// Проверка предельной гибкости в плоскости XZ, п. 10.4.1, 10.4.2, табл. 33
		   lambda_u = data_check->Limit_lambda_plus;
		   MAXNNEL(krit[1], lambdaX[n_elem]/(k_*lambda_u), 1);
		  if (krit[1] > krit_tens_max) {
			krit_tens_max = krit[1];
			RSU_tens_max = n_elem;
		  }
		}
		if (data_check->Checked[2]) {
		// Проверка предельной гибкости в плоскости YZ, п. 10.4.1, 10.4.2, табл. 33
		   lambda_u = data_check->Limit_lambda_plus;
		   MAXNNEL(krit[2], lambdaY[n_elem]/(k_*lambda_u), 2);
		  if (krit[2] > krit_tens_max) {
			krit_tens_max = krit[2];
			RSU_tens_max = i;
		  }
		}
	  }
	  n_elem = ListElem_RSU[RSU_tens_max];
		  memcpy((char*)&(Cp->param_sect), (char*)&(param_sect), sizeof(GEOM_PARAM_SECT));
		  memcpy((char*)&(Cp->param_netto), (char*)&(param_netto), sizeof(GEOM_PARAM_SECT));
		  memcpy((char*)&(Cp->Sect_Elem), (char*)&(Sect_Elem_Group[0]), sizeof(DATA_SECT_SCAD));
		  Cp->RSU[0][0] = Elem_RSU[RSU_tens_max][0];
		  Cp->num_elem[0] = n_elem;
		  strcpy(Cp->Steel, MaterPropU_prof.title);
		  Cp->Ryn = steel_param.Ryn;
		  Cp->hsect = h_;
		  Cp->bsect = b_;
		  Cp->diametr = h_;
		  Cp->bef = bef;
		  Cp->hef = hef;
		  Cp->Ry = Ry;
		  //Cp->Ryw = Ryw;
		  //Cp->Rs = Rsw;
		  Cp->Ryw = Ry;
		  Cp->Rs = Rs;
 		  Cp->A_netto = param_netto.Ar;
		  Cp->k_ = k_;
		  Cp->lambda_x = lambda_x[n_elem];
		  Cp->lambda_y = lambda_y[n_elem];
		  Cp->lambda_w = lambda_w;
		  Cp->lambda_uw = lambda_uw[n_elem];
		  Cp->lambda_f = lambda_f;
		  Cp->lambda_ux = lambda_u;
		  Cp->lambda_uy = lambda_u;
		  Cp->lambdaX = lambdaX[n_elem];
		  Cp->lambdaY = lambdaY[n_elem];
		  Cp->lambda_x = lambda_x[n_elem];
		  Cp->lambda_y = lambda_y[n_elem];
		  Cp->lambda_w = lambda_w;
		  Cp->lambda_uw = lambda_uw[n_elem];
		  Cp->lambda_f = lambda_f;
		  Cp->lambda_uf = lambda_uf[n_elem];
		  //Cp->lambda_f1 = lambda_f1;
		  //Cp->lambda_f2 = lambda_f2;
		  Cp->lambda_f1 = 0;
		  Cp->lambda_f2 = 0;
		  Cp->fi_x = fi_x[n_elem];
		  Cp->fi_y = fi_y[n_elem];
		  Cp->Ad = Ad[n_elem];

		  memcpy((char*)&Data_check_U, (char*)data_check, sizeof(DATA_CHECK_U));
 }

#include "CheckExecuteU_Tube%Centr_Compression_tube.cpp"
#include "CheckExecuteU_Tube%Compression_Bending_tube.cpp"
#include "CheckExecuteU_Tube%Bending_tube.cpp"
#include "CheckExecuteU_Tube%Tension_Bending_tube.cpp"

   *n_krit = data_check->num_krit;
   memcpy((char*)&Data_check_U, (char*)data_check, sizeof(DATA_CHECK_U));

   return 0;
}
