//----------------------------------------------------------------------------------------------------
//  Определить условия и тип проверки для для элеметов
int TCheckExecute::SetConditionCheck(DATA_CHECK_U *data_check, bool *flag_check)
//, int *index_M_max0, int *index_N_plus0, int *index_N_minus0)
{
   int numUnit;
   int i,j, k, l;
   char stroka[1000];
   bool flag_select;

   double N_;
   int numelem;
   int ngroup;
   //int nelem;
   GEOM_PARAM_SECT param_sect;
   bool flag_RSU[6];

   numUnit = 0;
   //
   int TypeNDS;
   int index_N_plus, index_M_max, index_N_minus;
   double N_plus_max, M_Nplus, N_minus_max, M_Nminus, M_max_max, N_Mmax, Q_Mmax;
   double Q_max_max, My_max_max, Qy_max_max;
   double eta_work[4];
   double ix_sect, l_ef, eta_, m_ef, lambda_x, lambda_x_r, M_, m_exc;
   double Ry, Ey;
   MATER_PARAM mater_param;
   int i_elem;
   double t_max;

   // номер группы
   ngroup = NumNameGroup[0];
   //nelem = NelemInGroup[ngroup+1];
   switch (Sect_Elem_Group[ngroup].type_sect) {
   case DVUTAVR:
   case TAVR:
   // Максимальная высота полки двутавра
	 t_max = MAX(Sect_Elem_Group[ngroup].com_sect.dvutavr.h1, Sect_Elem_Group[ngroup].com_sect.dvutavr.h2);
	 if (data_check->flag_composed)
	    t_max = MAX(t_max, data_check->plate_thick);
   break;
   case SQUARE_TUBE:
	 t_max = Sect_Elem_Group[ngroup].com_sect.square.thickness;
   break;
   case RECT_TUBE:
	 t_max = Sect_Elem_Group[ngroup].com_sect.rect.b1;
   break;
   case CIRCULAR_TUBE:
	 t_max = Sect_Elem_Group[ngroup].com_sect.circ.thickness;
   break;
   }
   double thick_range[2];
   strcpy(Msteel_prof, MaterPropU_prof.title);

   thick_prof = t_max;
   AnsiString Astr = MaterPropU_prof.title;
   int rc = Get_thick_range(MaterPropU_prof.title, t_max, thick_range);
   if (rc==steel_NO_STEEL) {
	   int i = Application->MessageBox((L"Стали " + Astr + L" нет в списке сталей").c_str(), L"",
								  MB_OK | MB_ICONERROR);
	   return rc;
   }
   thick_range_material[0] = thick_range[0];
   thick_range_material[1] = thick_range[1];
   if (rc > 0) {  // толщины не попадают в диапазон толщин
	 return rc;
   }
   //  Получить таблицу свойств стали по марке стали и проверить границы толщин
   rc = Get_Mater_param(MaterPropU_prof.title, &mater_param);
   if (rc>0) return rc;
	// Расчетное сопротивление растяжению, сжатию и изгибу по пределу текучески
   Ry = Steel_param_Ry(MaterPropU_prof.title, t_max, &rc, true);
   Ey = MaterPropU_prof.E;

   flag_check[0] = flag_check[1] = flag_check[2] = flag_check[3] = flag_check[4] = false;
   // Классификация элементов по виду НДС
   for (i=0; i<NRSU; i++) {
	 i_elem = ListElem_RSU[i];
	 CheckElem[i][0] = false;
	 CheckElem[i][1] = false;
	 CheckElem[i][2] = false;
	 CheckElem[i][3] = false;
	 CheckElem[i][4] = false;
   // Вычислить геометрические характеристики сечения группы
	 Get_param_sect_comm(Sect_Elem_Group[ngroup].type_sect, &(Sect_Elem_Group[ngroup].com_sect), &param_sect);
	 if (param_sect.Ar == 0) {
	  #ifdef EMBRAC
	 i = Application->MessageBox(L"SetConditionCheck:Программная ошибка. Площадь сечения равна нулю", L"", MB_OK | MB_ICONERROR);
	  #else
	 i = Application->MessageBox("SetConditionCheck:Программная ошибка. Площадь сечения равна нулю","", MB_OK | MB_ICONERROR);
	  #endif
	 return 1;
	 }
   //InfMessage("Ar ="+FloatToStr(param_sect.Ar)+", Wc ="+FloatToStr(param_sect.Izz/param_sect.Zct));
	 ix_sect = Round(sqrt(param_sect.Izz/param_sect.Ar), 1);
	 if (data_check->length_XZ[i_elem] <= 0) {
		#ifdef EMBRAC
	   i = Application->MessageBox(L"Не определена расчетная длина в плоскости XZ", L"", MB_OK | MB_ICONWARNING);
		#else
	   i = Application->MessageBox("Не определена расчетная длина в плоскости XZ","", MB_OK | MB_ICONWARNING);
		#endif
	   l_ef = 5000;
   }
   else
	 l_ef = data_check->length_XZ[i_elem];


	 lambda_x = l_ef/sqrt(param_sect.Izz/param_sect.Ar);     // гибкость элемента l_efx/i
	 lambda_x_r = Round(lambda_x*sqrt(Ry/Ey), 2);                     // относительная гибкость в плоскости рамы

	 N_plus_max=0; M_Nplus=0; N_minus_max=0; M_Nminus=0; M_max_max=0; N_Mmax=0; Q_Mmax=0;
	 Q_max_max=0;  My_max_max=0; Qy_max_max=0;

	 n_RSU_N_plus = -1;
	 n_RSU_N_minus = -1;
	 n_RSU_M_max = -1;
	 n_RSU_Q_max = -1;
	 n_RSU_My_max = -1;
	 n_RSU_Qy_max = -1;

	  if (N_plus_max < Elem_RSU[i][0]) {
		N_plus_max = Elem_RSU[i][0];
		M_Nplus = Elem_RSU[i][2];
		n_RSU_N_plus = i;
	  }
	  if (N_minus_max > Elem_RSU[i][0]) {
        N_minus_max = Elem_RSU[i][0];
		M_Nminus = Elem_RSU[i][2];
        n_RSU_N_minus = i;
	  }
      if ((ABS(M_max_max)) < (ABS(Elem_RSU[i][2]))) {
		M_max_max = Elem_RSU[i][2];
        N_Mmax = Elem_RSU[i][0];
        Q_Mmax = Elem_RSU[i][3];
		n_RSU_M_max = i;
      }
      if ((ABS(Q_max_max)) < (ABS(Elem_RSU[i][3]))) {
		Q_max_max = Elem_RSU[i][3];
		n_RSU_Q_max = i;
	  }
      if ((ABS(My_max_max)) < (ABS(Elem_RSU[i][4]))) {
		My_max_max = Elem_RSU[i][4];
        n_RSU_My_max = i;
      }
	  if ((ABS(Qy_max_max)) < (ABS(Elem_RSU[i][5]))) {
		Qy_max_max = Elem_RSU[i][5];
        n_RSU_Qy_max = i;
      }

	  N_Mmax *= 1e3;            // Продольная сила при максимальном моменте
	  M_max_max *= 1e6;         // Максимальный по ABS момент
	  Q_max_max *= 1e3;         // Максимальный по ABS момент
	  N_minus_max *= 1e3;       // Максимальная сжимающая сила
	  M_Nminus *= 1e6;          // Момент при максимальной сжимающей силе
	  N_plus_max *= 1e3;        // Максимальная растягивающая сила
	  M_Nplus *= 1e6;           // Момент при максимальной растягивающей силе
	  Q_Mmax *=1e3;             // Максимальная перерезывающая сила

	  if ((ABS(N_Mmax)) > data_check->N_plus*1e3) {
		m_exc = (ABS(M_max_max/N_Mmax))*param_sect.Ar*param_sect.Hsect*0.5/param_sect.Izz;  // ф. стр. 15
	  // Вычисление eta
		eta_ = Fun_eta_sect_plate(Sect_Elem_Group[ngroup].type_sect, &(Sect_Elem_Group[ngroup].com_sect), lambda_x_r, m_exc, eta_work, 0,
								  data_check->plate_width, data_check->plate_thick, data_check->index_composed);
		m_ef = eta_*m_exc;                          // ф. 52
		index_M_max = GetIndex_NDS(data_check, N_Mmax, M_max_max, ix_sect, l_ef, m_ef);
	  }
	  else {
		if ((ABS(M_max_max)) > data_check->M_max_i*1e6) {
		  index_M_max = BENDING;
		}
		else
		  index_M_max = -1;
	  }
      // По поперечной силе
	  if ((ABS(Q_max_max)) > 0.5e3 && N_plus_max == 0 && N_minus_max ==0 && M_max_max == 0) {
		  index_M_max = BENDING;
	  }

	// По растягивающей силе
	  if (N_plus_max > data_check->N_plus*1e3) {
		m_exc = (ABS(M_Nplus/N_plus_max))*param_sect.Ar*param_sect.Hsect*0.5/param_sect.Izz;  // ф. стр. 15
	// Вычисление eta
		eta_ = Fun_eta_sect_plate(Sect_Elem_Group[ngroup].type_sect, &(Sect_Elem_Group[ngroup].com_sect), lambda_x_r, m_exc, eta_work, 0,
								  data_check->plate_width, data_check->plate_thick, data_check->index_composed);
		m_ef = eta_*m_exc;                          // ф. 52
		index_N_plus = GetIndex_NDS(data_check, N_plus_max, M_Nplus, ix_sect, l_ef, m_ef);
	  }
	  else
		index_N_plus = -1;
	// По сжимающей силе
	  if (N_minus_max < data_check->N_minus*1e3) {
		m_exc = (ABS(M_Nminus/N_minus_max))*param_sect.Ar*param_sect.Hsect*0.5/param_sect.Izz;  // ф. стр. 15
	// Вычисление eta
		eta_ = Fun_eta_sect_plate(Sect_Elem_Group[ngroup].type_sect, &(Sect_Elem_Group[ngroup].com_sect), lambda_x_r, m_exc, eta_work, 0,
								  data_check->plate_width, data_check->plate_thick, data_check->index_composed);
		m_ef = eta_*m_exc;                          // ф. 52
		index_N_minus = GetIndex_NDS(data_check, N_minus_max, M_Nminus, ix_sect, l_ef, m_ef);
	  }
	  else
		index_N_minus = -1;

	  if (index_M_max == -1 && index_N_plus == -1 && index_N_minus == -1 ) {
		if (!data_check->flag_bending) {
			index_N_minus = CENTR_COMPRESSION;
	  /*
	  #ifdef EMBRAC
		i=Application->MessageBox((L"На участке "+IntToStr(i_elem+1) + "Величина РСУ мала, элемент рассматривается как центрально сжатый").c_str(), L"",
				MB_OK | MB_ICONWARNING);
	  #else
		i=Application->MessageBox("Для выбранной группы элементов все РСУ нулевые", "",
				MB_OK | MB_ICONWARNING);
	  #endif
	   */
		}
		else {
			index_M_max = BENDING;
		   //	i=Application->MessageBox(L"Величина РСУ на балке мала, элемент рассматривается как изгибаемый", L"",
		   //		MB_OK | MB_ICONWARNING);
		}
	  }
	  if (data_check->flag_bending) {
		if (index_M_max != BENDING) {
		   AnsiString pr=" ";
			i=Application->MessageBox((L"РСУ на балке не соответствует изгибаемому элементу." +  pr +
									   "\nДля того, чтобы выполнить проверки на заданные РСУ, необходимо переключить опцию" + pr +
									   "на панели \"Расчетные сочетания усилий\", и задать расчетные длины").c_str(), L"",
				MB_OK | MB_ICONERROR);
			return 99;
		}
	  }

	  // Установить флаги проверок
	  SetFlagCheck(index_M_max, data_check, flag_check);
	  SetFlagCheck(index_N_plus, data_check, flag_check);
	  SetFlagCheck(index_N_minus, data_check, flag_check);

	  // Установить флаги проверок для данного РСУ
	  flag_RSU[0] = flag_RSU[1] = flag_RSU[2] = flag_RSU[3] = flag_RSU[4] = false;
	  SetFlagCheck(index_M_max, data_check, flag_RSU);
	  SetFlagCheck(index_N_plus, data_check, flag_RSU);
	  SetFlagCheck(index_N_minus, data_check, flag_RSU);

	  for (j=0; j<NUMBER_CHECK; j++)
		 CheckElem[i][j] = flag_RSU[j];
	// Установить таблицы проверок
	  //SetTypeCheck(index_M_max);
	  //SetTypeCheck(index_N_plus);
	  //SetTypeCheck(index_N_minus);

	  //*index_M_max0 = index_M_max;
	  //*index_N_plus0 = index_N_plus;
	  //*index_N_minus0 = index_N_minus;
	}
	return 0;
}
//----------------------------------------------------------------------
//
void TCheckExecute::SetFlagCheck(int index_Type, DATA_CHECK_U *data_check, bool *flag_check)
{

	int index_sect = Sect_Elem_Group[NumNameGroup[0]].type_sect;

	switch (index_Type) {
	 //case chCENTR_TENSION:
	 case CENTR_TENSION:
	   flag_check[0] = true;
	   //PutFlagCentr_Tension(true);
	 break;
	 //case chCENTR_COMPRESSION:
	 case CENTR_COMPRESSION:
	   flag_check[1] = true;
	   //PutFlagCentr_Compression(true);
	 break;
	 //case chCOMPRESSION_BENDING:
	 case COMPRESSION_BENDING:
	   switch (index_sect) {
	   case DVUTAVR:  // Двутавровое сечение
		  flag_check[2] = true;
		  //PutFlagCompression_Bending_Const(true);
	   break;
	   default:
		  flag_check[2] = true;
		  //PutFlagCompression_Bend_Truba(true);
	  }
	 break;
	 //case chBENDING:
	 case BENDING:
	   if (data_check->index_class == 1 || data_check->index_class == 2 || data_check->index_class == 3) {
		 if (index_sect==DVUTAVR) {
		   flag_check[3] = true;
		   //PutFlag_Bending(true);
		 }
		 else {
		   flag_check[3] = true;
		   //PutFlag_Bending_Truba(true);
		 }
	   }
	 break;
	 case TENSION_BENDING:
		   flag_check[4] = true;
	 break;
	 default:
	 ;
	}

}

