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

#include <vcl.h>
#pragma hdrstop

#include "ChosenKolonna.h"
#include "KoeffLen.h"
#include "ChosenSect.h"
#include "CheckParam.h"
#include "AnalisParam.h"
#include "Generator.h"
#include "Data_Gen.h"
#include "message.h"             
#include "Analysis.h"
#include "bkerip.h"
#include "bkerip_ext.h"
#include "ListConst.h"
#include "SortP.h"
#include "ProcExt.h"
#include "Mesh_beta.h"
#include "CheckParam.h"
#include "DrawResult.h"
#include "Mesh_Sect.h"
#include "Edge_Param.h"
#include "StandartProfil.h"
#include "Proc_main.h"
#include "QuakeData.h"
#include "sigma_beam.h"
#include "EMBRAC.h"


//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "Sect_Param"
#pragma link "ParamChoseSect"
#pragma resource "*.dfm"

//#define PRINT_DEBUG

TChosenKolonnaForm *ChosenKolonnaForm;

bool flag_choose_kol_visible_next_step=true;

extern PARAM_CHOSEN_SECT Param_chosen_sect;

extern double sigma_external;
extern double sigma_internal;

extern bool flag_simm;
extern bool flag_sect_change; // флаг изменения параметров сечения
extern bool flag_mesh_plate;  // флаг разбиения пластинами

extern int  index_shema;   // признак схемы chemaXYZ = 0; shemaXZ = 1;

extern ANALYS_PARAM  Analys_param;
extern ADD_PARAM_RAMA Add_param_rama;          // дополнительные параметры рам

extern int Count_result;       // Количество наборов результатов
extern int Count_stress;       // Количество типов жесткостей

extern int    N_variant_analysis;      // Число вариантов анализа
extern int    N_base_variant;          // число базовых вариантов
extern VAR_ANALYSIS *Var_analysis;     // Вектор вариантов анализа
extern   int nnel;        /* число элементов */
extern   CONT *cont;      /* оглавление по элементам */
extern   DSC_MVC topo;    /* топология */
extern   DSC_MVC stif;    /* жесткости */

extern COM_RAMA Common_rama;
extern CHECK_PARAM Check_Param;
extern SECT_DVUTAVR *sect;
extern VIEW_SELECT  View_select;

extern DATA_SECT Main_Section[MAX_MAIN_SECT];
extern DATA_SECT Add_Section[MAX_ADD_SECT];
extern DATA_SECT_COM Sect_kol_rama5[2];  // данные о сечении колонн рамы-5 (тип - определен флагом type_section)
extern ADD_SPAN  Add_span[MAX_ADD_SPAN];
extern int Number_span;  // число пролетов для рам 4 и 5
extern int index_choice[MAX_ADD_SECT];
extern int Index_coor[MAX_MAIN_SECT + MAX_ADD_SECT + MAX_EDGE];
extern int n_base_sect;  // число базовых сечений -> число элементов в Index_coor
extern DSC_MVC node_load;    /* линии узлов приложения нагрузки */
extern DSC_MVC elem_load;    /* линии элементов приложения нагрузки */
extern int  *Elem_group;  // Обозначение группы, к которой принадлежит элемент
extern LENGTH_PARAM  Length_param;

extern MATER MaterProp[MAX_MATERIAL];
extern int Material_Number;
extern int  index_type_element;          // тип конструктивного элемента, на котором расположено проверяемое сечение

extern char FileDisp[5][40];
extern char FileStress[5][40];
extern int index_RSU;
extern PREFERENCES Preferences;                // Начальные установки


extern JOINT_PARAM  ChosenSect[MAX_ADD_SECT];   // параметры сечений

static SECT_DVUTAVR sect_dubl;
	  #ifdef EMBRAC
static String text, header;
	  #else
static AnsiString text, header;
	  #endif
static AnsiString Astr;
static int n_main_sect;  // число главных сечений

static double Add_chosen_param[MAX_ADD_SECT][3];  // дополнительные параметры: mu_x, mu_y, l_kol
static FILE *stress;
static double **mat_stress = NULL;
static int n_elem[MAX_ADD_SECT];   // номера элементов
static int n_nuz[MAX_ADD_SECT];    // порядковые номера узлов
static double Ry, Rs, Ey, round_h, round_width, ind_round_thick;
static double gamma_c_rig, gamma_c_kol_outer, gamma_c_kol_interior;
static double min_tpol, max_tpol, min_tsten, max_tsten, min_bpol, max_bpol, min_hsten;
static int ind_minimax;

static SECT_DVUTAVR *sect_right;
static int n_shift_right_sect;
static int list_j_comb[MAX_MAIN_SECT];    // номера комбинаций, по которым выбраны силовые факторы
//double Fun_eta(double A_, double lambda_, double m_);
//---------------------------------------------------------------------------
__fastcall TChosenKolonnaForm::TChosenKolonnaForm(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::FormShow(TObject *Sender)
{
      BitBtn_SetParamClick(Sender);   
      BitBtn_ChoiceSelect->Enabled=false;
      if (Add_param_rama.index_result==0)
         BitBtn_SetAnalyse->Enabled = true;
      else
         BitBtn_SetAnalyse->Enabled = false;
      ParamChoseSect_Frame1->GroupBox_Sect->Visible = false;
	  ParamChoseSect_Frame1->RadioGroup_sort->ItemIndex = Preferences.index_round_thick;


}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::Sect_ParamFrame1Button_ApplyClick(
      TObject *Sender)
{
      int i_sect, rc;

      Sect_ParamFrame1->Button_ApplyClick(Sender);
      if (flag_simm && sect_right != NULL) {
          memcpy(sect_right, sect, sizeof(SECT_DVUTAVR));
      }

      i_sect = ListBoxChosen->ItemIndex;
      if (ChosenSect[i_sect].local_sect == KOLONNA_LEFT) {
          memcpy(&(Sect_kol_rama5[0].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
          if (Common_rama.simm)
              memcpy(&(Sect_kol_rama5[1].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
      }
      if (ChosenSect[i_sect].local_sect == KOLONNA_RIGHT) {
          memcpy(&(Sect_kol_rama5[1].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
          if (Common_rama.simm)
              memcpy(&(Sect_kol_rama5[0].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
      }

      rc = draw_all();

}
//---------------------------------------------------------------------------
// изменение сечения
void __fastcall TChosenKolonnaForm::ChangeSect(TObject *Sender) {
      int i_sect, rc;


      rc = draw_all();
      i_sect = ListBoxChosen->ItemIndex;
      Sect_ParamFrame1->Check_Original();  // Установка поля рисования сечения
      Sect_ParamFrame1->Label_Sect->Caption = ListBoxChosen->Items->Strings[i_sect];
      if (flag_simm==true)
         Sect_ParamFrame1->Label_Side->Caption="";
      else
         Sect_ParamFrame1->Label_Side->Caption="Левая сторона";

      switch (ChosenSect[i_sect].type_sect) {
        case nMAIN_SECT:
          sect = &(Main_Section[ChosenSect[i_sect].index_sect].section);

          Set_index_type_element(Main_Section[ChosenSect[i_sect].index_sect].local_sect);

          if (flag_simm==true)  // для основных сечений все правые следуют после левых, во второй половине списка
             sect_right = &(Main_Section[ChosenSect[i_sect].index_sect + n_shift_right_sect].section);
          else
             sect_right=NULL;
        break;
        case nSPAN_SECT:
          sect = &(Add_span[ChosenSect[i_sect].index_sect].sect_kol.dvutavr);

          index_type_element = typeCOMP_7_23;

          if (flag_simm==true)  // правые сечения для колонн
             sect_right = &(Add_span[Number_span - ChosenSect[i_sect].index_sect -2].sect_kol.dvutavr);
          else
             sect_right=NULL;
          index_choice[0] = ChosenSect[i_sect].index_sect;
          index_choice[1] = -1;
        break;
        default:
          ErrorMessage("ChosenSectForm: Тип сечения "+IntToStr(ChosenSect[i_sect].type_sect)+" не обрабатывается");
          return;
      }
      if (BitBtn_ChoiceSelect->Enabled) {
        //Label_Mz->Caption = "Mz="+FloatToStrF(mat_stress[i_sect][2]*1e-6, ffFixed, 15, 0)+" кН*м";
        //Label_Nx->Caption = "Nx="+FloatToStrF(mat_stress[i_sect][0]*1e-3, ffFixed, 15, 0)+" кН";
        Label_Mz->Caption = "Mz="+FloatToStrF(mat_stress[i_sect][2]*1e-3, ffFixed, 15, 0)+" Н*м";
        Label_Nx->Caption = "Nx="+FloatToStrF(mat_stress[i_sect][0], ffFixed, 15, 0)+" Н";
        // Label_Qy->Caption = "Qy="+FloatToStrF(mat_stress[i_sect][1]*1e-3, ffFixed, 15, 0)+" кН";
        Label_Qy->Caption="";
        Label_Comb->Caption = "Комбинация "+IntToStr(list_j_comb[i_sect]+1) + ": "+
                              AnsiString(Var_analysis[list_j_comb[i_sect]].var_name);
      }
      else {
        Label_Mz->Caption="";
        Label_Nx->Caption="";
        Label_Qy->Caption="";
        Label_Comb->Caption="";
      }
      Sect_ParamFrame1->Write_sect(Sender);
      BitBtn_Return->Enabled = false;

      flag_sect_change=false;
}
//---------------------------------------------------------------------------
// Установить номера элементов сечений и порядковые номера узлов
void __fastcall TChosenKolonnaForm::SetElem_in_Sect() {
   int i, k, i_sect;
   int k1, j, n_line, n_line_el;
   int * vec_node;
   int * vec_elem;
   float *nuz;
   int rc, n_node, nuz_elem;
   bool flag_switch;  // Флаг переключения для внутренних сечений
   int kol_elem_third[MAX_ADD_SPAN];     // номер элемента на 1/3 колонны
   int kol_elem_max[MAX_ADD_SPAN];    // номер элемента внизу колонны
   int kol_elem_up[MAX_ADD_SPAN];    // номер элемента внизу колонны

   // установка номеров элементов на 1/3 колонн
   Set_medium_elem(kol_elem_third, kol_elem_max, kol_elem_up);

   for (i_sect=0; i_sect<ListBoxChosen->Count; i_sect++) {
      // определить параметры для подбора сечений
      switch (ChosenSect[i_sect].local_sect) {
      case KOLONNA_LEFT:
         n_elem[i_sect] = kol_elem_max[0];
      break;
      case KOLONNA_RIGHT:
         n_elem[i_sect] = kol_elem_max[1];
      break;
      default:
         k = ChosenSect[i_sect].local_sect/11 - 1;
         n_elem[i_sect] = kol_elem_max[k+2];
      }
         //InfMessage("Номер элемента в сечении "+IntToStr(n_elem[i_sect]));
        //InfMessage("Номер узла в сечении "+IntToStr(nuz_elem));
        // чтение топологии
        if (n_elem[i_sect]<0) {
           ErrorMessage("Программная ошибка в ChosenKolonnaForm->SetElem_in_Sect ");
           return;
        }
        nuz = (float*)almvec(&topo, n_elem[i_sect], &n_node, &rc);
        if (rc>0) {
           ErrorMessage("Программная ошибка в ChosenKolonnaForm->SetElem_in_Sect (нет записи в topo)");
           return;
        }
        n_nuz[i_sect]=0;
     }
     n_elem[i_sect]=-1;   // заглушка
     // Напряжения во втором узле для первого и последнего элемента
     //n_nuz[0] = 1;
     //n_nuz[ListBoxChosen->Count-1] = 1;
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::ListBoxChosenClick(TObject *Sender)
{
    int i;

      for (i=0; i<ListBoxChosen->Items->Count; i++) {
          if (ListBoxChosen->Selected[i])
              break;
      }
      ListBoxChosen->ItemIndex=i;
      ChangeSect(Sender);
}
//---------------------------------------------------------------------------
/* Подбор параметров сечений
void __fastcall TChosenKolonnaForm::BitBtnChosenClick(TObject *Sender)
{
      int i_sect, rc;
      i_sect = ListBoxChosen->ItemIndex;
      rc = GetParam();
      if (rc>0) return;

      ChoiseKolonna_Alg(ChosenSect[i_sect].local_sect,
                        Add_chosen_param[i_sect][0], Add_chosen_param[i_sect][1], Add_chosen_param[i_sect][2],
                        mat_stress[i_sect][0], mat_stress[i_sect][1], mat_stress[i_sect][2], Sender);
      rc = draw_all();
}
*/
//---------------------------------------------------------------------------
// Выполнить подбор сечения для колонн постоянного сечения
void __fastcall TChosenKolonnaForm::ChoiseKolonna_Alg(int local_sect, double mu_x, double mu_y, double l_kol, double Nx, double Qy, double Mz, TObject *Sender) {
     GEOM_PARAM_SECT param_sect;
     double kR;
     double sig_ext, sig_int;
     double lambda_w, lambda_x, lambda_;
     double fi_e, h_opt, hw, tw, tf, bf, mult_ix, ix;
     int i;
     double gamma_c;
     double e_, lx_ef, ly_ef, Bx_, By_;
     double dzeta, omega, Const0, Const1, lambda_f;
     double lambda_y, Rel_u, ksi_, dzeta_sk, u_, uef, Cx_, Delta, Delta_e;
     double Ar_, Rel_A, eta, omega_ef, k_;
     double m_exc, lam, Add_koef, Up_lambda_w, ss;
     int n_loop;
     double eta_work;
     TStandartProfil StandartProfil;



     switch (local_sect) {
      case KOLONNA_LEFT:
      case KOLONNA_RIGHT:
        gamma_c = Param_chosen_sect.gamma_c_kol_outer;
      break;
      default:
        gamma_c = Param_chosen_sect.gamma_c_kol_interior;
     }

     /*   тест для гибкой стенки
     mu_x = 2.0;
     mu_y = 0.8;
     l_kol =8600;
     Nx = 259294;
     Mz = 71761000;
     gamma_c =0.95;
     */
     /* тест для устойчивой стенки
     mu_x = 2.0;
     mu_y = 0.4615;
     l_kol =7800;
     Nx = 930000;
     Mz = 319000000;
     gamma_c =1.0;
     Ry = 210;
     */

     Mz =ABS(Mz);
     Nx=ABS(Nx);
     // 1. Предварительный расчет
     // Эксцентриситет
     e_ = Mz/Nx;
     // Расчетные длины
     lx_ef = mu_x*l_kol;
     ly_ef = mu_y*l_kol;

     char stroka[240];
     #ifdef PRINT_DEBUG
     InfMessage("Alg_Gepard-----------------");
     sprintf(stroka, "lx_ef=%10.2f, ly_ef=%10.2f, e_=%10.2f", lx_ef, ly_ef, e_);
     InfMessage((AnsiString)stroka);
     #endif
     n_loop =0;
loop0:
     // Вычисление характерных параметров - перенесено за метку, т. Ry может уточняться (пока не сделано)
     kR = sqrt(Ey/Ry);

     Bx_ = Nx*Ey/(Ry*gamma_c*Ry*lx_ef*lx_ef);

     dzeta = lx_ef/(2*ly_ef);

     omega = 1.3*e_* kR/lx_ef;

     By_ = Nx*Ey/(Ry*gamma_c*Ry*ly_ef*ly_ef);

     Const0 = 5.0*(1+0.26*dzeta*dzeta)*(1+0.26*dzeta*dzeta)*sqrt(Ry/Ey)/(1+1.8*omega);
     Const1 = (1+0.26*dzeta*dzeta)*(1+0.26*dzeta*dzeta)*sqrt(Ry/Ey)/(1+2.9*omega);

     if (By_ > Const0) {
       lambda_ = 1.0;
       By_ = Const0;
     }
     else {
       if (By_ <= Const0 && By_ >= Const1) lambda_ = 2.0;
       if (By_ < Const1) lambda_ = 3.0;
     }
     if (Param_chosen_sect.ind_gib)  // гибкая стенка
       lambda_y = 1.5*lambda_;
     else
       lambda_y = lambda_;

     // Конец вычисления характерных параметров
     // Начало итераций
loop:
     // Гибкость поясов
     lam = MAX(0.8, lambda_);
     lam = MIN(4.0, lambda_);
     lambda_f = 2.0*(0.36 + 0.1*lam)*kR;

     if (Param_chosen_sect.ind_gib) { // гибкая стенка
        Add_koef = 1.7;
        Up_lambda_w = 4.6*kR;
        if (lambda_<2.0)
          lambda_w = Add_koef*(1.3 +0.15*lambda_*lambda_)*kR;
        else
          lambda_w = Add_koef*(1.2 +0.35*lambda_)*kR;
        lambda_w = MIN(Up_lambda_w, lambda_w);
        //lambda_y = 1.5*lambda_;
        Rel_u = 1.7*kR/lambda_w;
        ksi_ = 3.0*Rel_u*(1 - Rel_u + Rel_u*Rel_u/3);
        ss = sqrt(2.0*ksi_*lambda_f*pow(lx_ef*lambda_y/(ly_ef*lambda_),2)/(9.0*lambda_w) + 1);
        dzeta_sk = sqrt((3.0 * lambda_w/(ksi_*lambda_f))*
                   (ss - 1));
        u_ = lambda_f*dzeta_sk*dzeta_sk/(2*lambda_w);
        uef = u_ * Rel_u;
     }
     else {
        if (lambda_<2.0)
          lambda_w = (1.3 +0.15*lambda_*lambda_)*kR;
        else
          //lambda_w = (1.2 +0.35*lambda_)*kR;
          lambda_w = (MIN(2.3, (1.2 +0.35*lambda_)))*kR;
        //lambda_y = lambda_;
        ksi_ = 1;
        ss = sqrt(2.0*ksi_*lambda_f*pow(lx_ef*lambda_y/(ly_ef*lambda_),2)/(9.0*lambda_w) + 1);
        dzeta_sk = sqrt((3.0 * lambda_w/(ksi_*lambda_f))*
                   (ss - 1));
        u_ = lambda_f*dzeta_sk*dzeta_sk/(2*lambda_w);
        uef = u_;
     }

     Cx_ = u_*(3.0+ksi_*u_)*lambda_w/(12.0*(1+uef)*(1+uef));
     Delta = Bx_*Cx_;
     omega  = sqrt(3.0*(1+uef)/(3 + ksi_*u_))*e_*kR/lx_ef;
     Delta_e = (1+3*pow(omega,0.75)/(4*pow(Delta,0.3333)))*Delta;
          // Уточнение Delta_e
     Delta_e = (1+omega*Delta_e/(pow(Delta_e+0.04, 1.5)))*Delta;
     Delta_e = MAX(0.03, Delta_e);
     
     lambda_x = 1/(sqrt(Delta_e+0.04));
     Ar_ = Nx *(1+omega*Delta_e/(pow(Delta_e+0.04, 1.5)))*
           (1 + 0.04/Delta_e)/(Ry*gamma_c);

     #ifdef PRINT_DEBUG
     sprintf(stroka, "lambda_f=%10.2f, lambda_y=%10.2f", lambda_f, lambda_y);
     InfMessage((AnsiString)stroka);
     sprintf(stroka, "lambda_w=%10.2f, u_=%10.2f, uef=%10.2f", lambda_w, u_, uef);
     InfMessage((AnsiString)stroka);
     sprintf(stroka, "Delta_e=%10.2f, lambda_x=%10.2f, Ar_=%10.2f", Delta_e, lambda_x, Ar_);
     InfMessage((AnsiString)stroka);
     #endif
     if ((ABS(lambda_x - lambda_))/lambda_ >0.05 && n_loop<5) {  // Повторение расчета
        lambda_y = lambda_y*lambda_x/lambda_;
        lambda_ = (lambda_ + 2*lambda_x)/3;
        //if (n_loop==0) {      // !!!!!!!!!!!!!!!!!! - отладка
        //  lambda_y = 1.957;
        //  lambda_ = 1.638;
        //}
        n_loop++;
        goto loop;
     }
     else {
        lambda_ = lambda_x;
     }
 //---------------------------------------------
 // Вычисление требуемой площади сечения
 // вычисление относительного эксцентриситета
     m_exc = omega*lambda_;
     m_exc = Round(m_exc, 2);

     Rel_A = 1/(2*u_);
     eta = Fun_eta(Rel_A, lambda_, m_exc, &eta_work);

     omega_ef = eta * omega;

     if (Delta>0.1) k_=0.16*(2+Delta)/(0.3+Delta);
     if (Delta<=0.1 && Delta>=0.03) k_=0.84;
     if (Delta<0.03) k_=0.51 + 11*Delta;
     if (Delta>=0.03) {
         lambda_x = 1/sqrt((1+k_*pow(omega_ef,0.8))*(0.035+Delta));
     }
     else {
         lambda_x = 1.67/(sqrt((1+k_*pow(omega_ef,0.8))*sqrt(Delta)));
     }
     fi_e = Delta*lambda_x*lambda_x;

     Ar_ = Nx/(fi_e*Ry*gamma_c);        // требуемая площадь сечения

     #ifdef PRINT_DEBUG
     sprintf(stroka, "2: lambda_x=%10.2f, Ar_=%10.2f", lambda_x, Ar_);
     InfMessage((AnsiString)stroka);
     #endif

     // Компоновка сечения
     mult_ix = sqrt((3+uef)/(12*(1+uef)));

     ix = lx_ef*sqrt(Ry/Ey)/lambda_x;   // радиус инерции

     h_opt = ix/mult_ix;                // высота сечения

     bf = h_opt/dzeta_sk;               // ширина полки

     tf = bf/lambda_f;                  // толщина полки
     tw = (h_opt - 2*tf)/lambda_w;      // толщина стенки

     if (ind_minimax==1) {   // Учитывать ограничения на размеры
       h_opt = MAX(h_opt - 2*tf, min_hsten) + 2*tf;
     // Повторное назначение размеров сечения
       bf = MAX(h_opt/dzeta_sk, min_bpol);               // ширина полки
       bf = MIN(h_opt/dzeta_sk, max_bpol);               // ширина полки

       tf = MAX(bf/lambda_f, min_tpol);                  // толщина полки
       tf = MIN(bf/lambda_f, max_tpol);                  // толщина полки

       tw = (h_opt - 2*tf)/lambda_w;      // толщина стенки
       tw = MAX(tw, min_tsten);
       tw = MIN(tw, max_tsten);
     }

     memcpy(&(sect_dubl), sect, sizeof(SECT_DVUTAVR));

     //--------------------------------------------------
     // Чтобы вычислить геометрические параметры сечения
     hw = Round_step(h_opt - 2*tf, Param_chosen_sect.round_h);
     sect->h = hw;
     sect->b = tw;
     sect->b1 = bf;
     sect->h1 = tf;
     sect->b2 = bf;
     sect->h2 = tf;
     // вычисление геометрических характеристик сечения
     Get_param_sect(sect, &(param_sect));
     double Izz0 = param_sect.Izz;

     if (sect->n_group < 0 ) {   // сварное сечение
       tf = Round_row(tf, ind_round_thick);
       if (ind_round_thick == 2) {
         for (i=0; i<4; i++) {
           double bef0 = Get_max_bpol(tf, ind_round_thick);
           if (bf > bef0) {
             sect->b1 = bef0;
             sect->h1 = tf;
             sect->b2 = bef0;
             sect->h2 = tf;
             Get_param_sect(sect, &(param_sect));
             if (param_sect.Izz < Izz0*0.99)
               tf = Round_row(tf+1, ind_round_thick);
             else
               break;
           }
         } 
       }
       bf = Round_row_bpol(tf, bf, Param_chosen_sect.round_width, ind_round_thick);
       tw = Round_row(tw, ind_round_thick);
       hw = Round_step(h_opt - 2*tf, Param_chosen_sect.round_h);

       sect->h = hw;
       sect->b = tw;
       sect->b1 = bf;
       sect->h1 = tf;
       sect->b2 = bf;
       sect->h2 = tf;
     }
     if (sect->n_group >= 0 ) {   // стандартное сечение
        //int rc = StandartProfil.Choice_Profil_param(sect, Ar_, ix, 0.0, h_opt, tw, tf, bf, true);
        int rc = StandartProfil.Choice_Profil_param(sect, Ar_, 0.0, 0.0, h_opt, tw, tf, bf, true);
        if (rc>0)
          return;
     }
     sect->flag_concl = true;
     // вычисление геометрических характеристик сечения
     Get_param_sect(sect, &(param_sect));
     // напряжения во внешнем поясе
     sig_ext = -param_sect.Zct*(Mz/param_sect.Izz) + Nx/param_sect.Ar;
     // напряжения во внутреннем поясе
     sig_int = (param_sect.Hsect - param_sect.Zct)*(Mz/param_sect.Izz) + Nx/param_sect.Ar;

     if (flag_simm && sect_right != NULL) {
          memcpy(sect_right, sect, sizeof(SECT_DVUTAVR));
     }

      Sect_ParamFrame1->Write_sect(Sender);

      sigma_external = sig_ext;
      sigma_internal = sig_int;

      Sect_ParamFrame1Button_ApplyClick(Sender);
      Sect_ParamFrame1->CheckBox1->Checked = false;
      Sect_ParamFrame1->CheckBox1->Enabled = true;

      sigma_external = 0;
      sigma_internal = 0;

      flag_sect_change=false;
      BitBtn_Return->Enabled = true;
}
//---------------------------------------------------------------------------
// Выполнить раcчет по результатам подбора
void __fastcall TChosenKolonnaForm::BitBtn_SetAnalyseClick(TObject *Sender)
{
    int rc;
    // Сохранить состояние модели
    GeneratorForm->SaveTemp(Sender);

    MeshForm->MeshApply(true, Sender);   // true - вывод рисунка

    GeneratorForm->ActiveCommand();

    rc = Call_Static(false, Sender);
    if (rc>0) {
         BitBtn_CancelClick(Sender);
    }

}
//---------------------------------------------------------------------------
//   Вызов статического решения
int __fastcall TChosenKolonnaForm::Call_Static(bool flag_set_param, TObject *Sender) {
     int i, rc;

     if (flag_set_param) {
       // Проверка условия наличия статического решения
       if (Add_param_rama.index_result==0 && (AnalisParamForm->ListBox_ChoiceLoad->Count==0 || Analys_param.type_analysis != aSTATIC ||
          Analys_param.n_var_load != N_base_variant ||
          Count_result == 0 || Count_stress == 0)) {

         AnalisParamForm->ComboBox_AnalysType->ItemIndex = 0;
         if (Analys_param.type_analysis != aSTATIC) {
           Analys_param.type_analysis = aSTATIC;
           Analys_param.n_var_load = 0;
         }
         AnalisParamForm->ComboBox_AnalysType->Enabled = false;

         AnalisParamForm->ShowModal();
         if (Analys_param.type_analysis !=0) {
           text="Должен быть выбран статический расчет";
           header="";
		   i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
           AnalisParamForm->ComboBox_AnalysType->Enabled = true;
           return 1;
         }
         if (Analys_param.n_var_load ==0) {
           text="Не выбрано ни одного варианта нагружения";
           header="";
           i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
           return 1;
         }
         if (Analys_param.n_var_load != N_base_variant) {
           text ="Число выбранных вариантов нагружения не совпадает с числом базовых вариантов в комбинациях загружений.  Возможно, необходимо вычислить РСУ и получить комбинации загружений";
           header="";
           i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
           return 1;
         }
         Count_result = 0;
         Count_stress = 0;
       }
     }
     else {
       Count_result = 0;
       Count_stress = 0;
     }
     if (Count_result==0) {
     // Выполнить расчет
       rc = stat_main(DISP_STATIC, STRESS_STATIC);
       if (rc>0) {
          text="Ошибка " + IntToStr(rc)+" при выполнении статического расчета, проверьте модель";
          header="";
          i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
          return 1;
       }
     }  
     /*
     View_select.contour_style = conNONE;

     DrawResultForm->ViewResult(combSTATIC);

     rc = draw_all();
     */
     // Получить требуемые силовые факторы
     Get_LoadFactor();

     AnalisParamForm->ComboBox_AnalysType->Enabled = true;

     BitBtn_ChoiceSelect->Enabled=true;
     //Sect_ParamFrame1->Button_Apply->Enabled=true;
     ChangeSect(Sender);
     //ListBoxChosen->ItemIndex=0;
     //ListBoxChosen->Selected[0]=true;
     return 0;
}
//----------------------------------------------------------------------------
int __fastcall TChosenKolonnaForm::GetParam()  {

       int rc = ParamChoseSect_Frame1->GetParam(SECT_KOLONNA);
       if (rc>0) return rc;
       
       gamma_c_rig = Param_chosen_sect.gamma_c_rig;
       gamma_c_kol_outer = Param_chosen_sect.gamma_c_kol_outer;
       gamma_c_kol_interior = Param_chosen_sect.gamma_c_kol_interior;

       round_h = Param_chosen_sect.round_h;
       round_width = Param_chosen_sect.round_width;
       ind_round_thick = Param_chosen_sect.round_thick;

       ind_minimax = Param_chosen_sect.ind_minimax;
       min_hsten = Param_chosen_sect.min_hsten;
       max_bpol = Param_chosen_sect.max_bpol;
       min_bpol = Param_chosen_sect.min_bpol;
       max_tpol = Param_chosen_sect.max_tpol;
       min_tpol = Param_chosen_sect.min_tpol;
       max_tsten = Param_chosen_sect.max_tsten;
       min_tsten = Param_chosen_sect.min_tsten;

       // Взаимное измененение gamma_c
       Check_Param.gamma_c_rig = Param_chosen_sect.gamma_c_rig;
       Check_Param.gamma_c_kol_outer = Param_chosen_sect.gamma_c_kol_outer;
       Check_Param.gamma_c_kol_interior = Param_chosen_sect.gamma_c_kol_interior;

       return 0;
}
//----------------------------------------------------------------------------
// Прочитать из файла напряжений требуемые силовые факторы
void __fastcall TChosenKolonnaForm::Get_LoadFactor() {

       int i, j, k, m, rc;
       int n_nel, n_disp;
       double **mat_element;
       double str_res[MAX_RES];
       double stress_el[5];
       int current_cod, cod_p;
       FELEM *felem;         /*  Структура данных о типе элемента  */
       double mz;
       char current_type[12];
       int list[MAX_ADD_SECT]; // порядковые номера элементов *2
       int n_sect, i_nuz;
       double *gt;
       int n_nst, j_min;
       double sigma[5][3], sig, sig_min;

       n_sect = ListBoxChosen->Count;

       for (i=0; i<n_sect; i++) {
           list[i] = i*2 + n_nuz[i];
       }
       // Сортировка номеров элементов
       qsortkr((char*)n_elem,(char*)list,(unsigned int)n_sect,SINT,WINT);

       if ((stress = fopen(FileStress[index_RSU], "rb")) == NULL) {
          ErrorMessage("Файл напряжений не получен");
          return;
       }

       READ(&n_nel,sizeof(int),1,stress);  // чтение числа элементов
       READ(&n_disp,sizeof(int),1,stress);  // чтение размера матрицы перемещений
       if (n_nel != nnel) {
          text="Неверный файл напряжений (Get_LoadFactor)";
          header="";
          i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
          return;
       }
       if (n_disp != N_base_variant) {
          text="Количество базовых вариантов в комбинациях не равно числу вариантов нагружений";
          header="";
          i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
          return;
       }

       if (mat_stress!=NULL) {
         FREEMAT_(mat_stress);
       }
       ALLOCMAT_(mat_stress, n_sect, 3);
       ALLOCMAT_(mat_element, n_disp, 5);

       // чтение файла перемещений и выбор варианта по максимуму напряжений во внешних волокнах
       cod_p = -1;
       m=0;
       for (i=0; i<nnel; i++) {
         if (cont[i].cod != BEAM) {
             ErrorMessage("Программная ошибка в ChosenSectForm (тип элемента не BEAM)");
             return;
         }
         if (cont[i].cod == BEAM && index_shema == shemaXZ) {
             current_cod = BEAMXZ;
             strcpy(current_type,"beamxz");
         }
         else  {
             current_cod = cont[i].cod;
             strcpy(current_type,cont[i].type);
         }
         if ( cod_p != current_cod) {
             cod_p = current_cod;
             felem=antype(cod_p);
             if (felem==NULL)
               return;
         }

         if (n_elem[m] == i) {
           VECTSEL_(&stif, gt, cont[i].gr_stf, n_nst, double); // прочитать жесткости
           i_nuz = list[m]%2;
           for (k=0; k<n_disp; k++) {
              READ(str_res, sizeof(double), felem->nrez, stress);
              if (rc != felem->nrez) {
                 text="Неверный файл напряжений (Get_LoadFactor 2)";
                 header="";
                 i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
                 FREEMAT_(mat_element);
                 return;
              }
              mat_element[k][0]=str_res[3];   // N
              mat_element[k][1]=str_res[4];   // Q

              if (i_nuz==0) {
                 mat_element[k][2]=str_res[10];  // M
              }
              else {
                 mat_element[k][2]=str_res[11];  // M
              }
              // Вычислить напряжения в среднем узле
              rc = sigma_beam_max(gt, mat_element[k], sigma,  0);
              if (rc>0) return;
              mat_element[k][3]=sigma[0][0];   // нормальные напряжения в наружном поясе
              mat_element[k][4]=sigma[1][0];   // нормальные напряжения во внутреннем поясе
           }

           mat_stress[m][0] = mat_stress[m][1] = mat_stress[m][2] = 0.0;
           sig_min = 0;
           for (j=0; j < N_variant_analysis; j++) {
              stress_el[0]=stress_el[1]=stress_el[2]=stress_el[3]=stress_el[4]=0.0;
              for (k=0; k<N_base_variant; k++) {
                  stress_el[0] += mat_element[k][0]*Var_analysis[j].var_koeff[k];  // N
                  stress_el[1] += mat_element[k][1]*Var_analysis[j].var_koeff[k];
                  stress_el[2] += mat_element[k][2]*Var_analysis[j].var_koeff[k];
                  stress_el[3] += mat_element[k][3]*Var_analysis[j].var_koeff[k];
                  stress_el[4] += mat_element[k][4]*Var_analysis[j].var_koeff[k];
              }
              sig = MIN(stress_el[3], stress_el[4]);  // минимальное (сжимающее) напряжение
              if (sig < sig_min) {
                 sig_min = sig;
                 j_min = j;
                 mat_stress[m][0] = stress_el[0];
                 mat_stress[m][1] = stress_el[1];
                 mat_stress[m][2] = stress_el[2];
              }
           }
           list_j_comb[m] = j_min;
           //InfMessage("Элемент "+IntToStr(i+1)+", вариант "+IntToStr(j_min+1));
           m++;
         }
         else {
           for (k=0; k<n_disp; k++) {
              READ(str_res, sizeof(double), felem->nrez, stress);
           }
         }
       }

       for (i=0; i<n_sect; i++) {
          list[i] /= 2;
       }

       rc = reps_m(list, mat_stress, n_sect, 3);
       FREEMAT_(mat_element);

       rc = fclose(stress);

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

void __fastcall TChosenKolonnaForm::BitBtn_CancelClick(TObject *Sender)
{
   Close();
}
//---------------------------------------------------------------------------
// Выполнить разбиение по результатам подбора
void __fastcall TChosenKolonnaForm::BitBtnDoneClick(TObject *Sender)
{
      int i, rc;
      // Сохранить состояние модели
      GeneratorForm->SaveTemp(Sender);

      if (Add_param_rama.index_result==1) {
		  i = ApplicationMessageBox("Получить сетку по результатам подбора сечений ?", "Подбор выполнен по усилиям, импортированным из SCAD",
          MB_YESNO | MB_ICONQUESTION);
          if (i == IDYES) {
            MeshForm->MeshApply(true, Sender);
            GeneratorForm->ActiveCommand();
          }
      }
      else {
        MeshForm->MeshApply(true, Sender);
        GeneratorForm->ActiveCommand();

        if (ParamChoseSect_Frame1->CheckBox_AutoAnalyse->Checked) {
          Count_result = 0;
          Count_stress = 0;
        // Выполнить расчет
          rc = stat_main(DISP_STATIC, STRESS_STATIC);
          if (rc>0) {
            text="Ошибка " + IntToStr(rc)+" при выполнении статического расчета, проверьте модель";
            header="";
            i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
            BitBtn_ChoiceSelect->Enabled=false;
            ListBoxChosen->Enabled=false;
            return;
          }
        }
      }
      Close();
}
//---------------------------------------------------------------------------

// Отменить подбор
void __fastcall TChosenKolonnaForm::BitBtn_ReturnClick(TObject *Sender)
{
        int rc;
        memcpy(sect, &(sect_dubl), sizeof(SECT_DVUTAVR));
        
        if (flag_simm && sect_right != NULL) {
          memcpy(sect_right, &(sect_dubl), sizeof(SECT_DVUTAVR));
        }
        Sect_ParamFrame1->Write_sect(Sender);
        flag_sect_change=false;
        BitBtn_Return->Enabled = false;
        rc = draw_all();

}
//---------------------------------------------------------------------------
// Подобрать параметры всех выбранных сечений
void __fastcall TChosenKolonnaForm::BitBtn_ChoiceSelectClick(TObject *Sender)
{
    int i_sect, rc;
    for (i_sect=0; i_sect<ListBoxChosen->Count; i_sect++) {
      if (ListBoxChosen->Selected[i_sect]) {
        switch (ChosenSect[i_sect].type_sect) {
        case nMAIN_SECT:
          sect = &(Main_Section[ChosenSect[i_sect].index_sect].section);

          Set_index_type_element(Main_Section[ChosenSect[i_sect].index_sect].local_sect);

          if (flag_simm==true)
             sect_right = &(Main_Section[ChosenSect[i_sect].index_sect+n_shift_right_sect].section);
          else
             sect_right=NULL;
        break;
        case nSPAN_SECT:
          sect = &(Add_span[ChosenSect[i_sect].index_sect].sect_kol.dvutavr);

          index_type_element = typeCOMP_7_23;

          if (flag_simm==true)  // правые сечения для колонн
             sect_right = &(Add_span[Number_span - ChosenSect[i_sect].index_sect -2].sect_kol.dvutavr);
          else
             sect_right=NULL;
          index_choice[0] = ChosenSect[i_sect].index_sect;
          index_choice[1] = -1;
        break;
        default:
          ErrorMessage("ChosenSectForm: Тип сечения "+IntToStr(ChosenSect[i_sect].type_sect)+" не обрабатывается");
          return;
        }

        ChoiseKolonna_Alg(ChosenSect[i_sect].local_sect,
                          Add_chosen_param[i_sect][0], Add_chosen_param[i_sect][1], Add_chosen_param[i_sect][2],
                          mat_stress[i_sect][0], mat_stress[i_sect][1], mat_stress[i_sect][2], Sender);
                          //31611.0, 0.0, 5978000.0, Sender);

        /*
        ChoiseKolonna_Alg0(ChosenSect[i_sect].local_sect,
                          Add_chosen_param[i_sect][0], Add_chosen_param[i_sect][1], Add_chosen_param[i_sect][2],
                          //31611.0, 0.0, 5978000.0, Sender);
                          mat_stress[i_sect][0], mat_stress[i_sect][1], mat_stress[i_sect][2], Sender);
        */
        // записать подобранное сечение для крайних колонн рамы 5-го типа на место
        switch (Common_rama.type_rama) {
        case ONE_SPAN_DOUBLE_UP:
        case ONE_SPAN_SINGLE_UP:
        case ONE_SPAN_DOWN:
        case MANY_SPAN_DOWN:
        case ARBIT_RAMA:
        case SEGMENT_RAMA:
        break;
        case MANY_SPAN_UP:
        case MANY_SPAN_UP_MK:
        case MANY_SPAN_LEVEL:
           if (ChosenSect[i_sect].local_sect == KOLONNA_LEFT) {
               memcpy(&(Sect_kol_rama5[0].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
               if (Common_rama.simm)
                   memcpy(&(Sect_kol_rama5[1].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
           }
           if (ChosenSect[i_sect].local_sect == KOLONNA_RIGHT) {
               memcpy(&(Sect_kol_rama5[1].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
               if (Common_rama.simm)
                   memcpy(&(Sect_kol_rama5[0].section.dvutavr), sect, sizeof(SECT_DVUTAVR));
           }
        break;
        default:
         Error_type_rama("BitBtn_ChoiceSelectClick");
         return;
        }
      }
    }
    rc = draw_all();
}
//---------------------------------------------------------------------------

void __fastcall TChosenKolonnaForm::BitBtn_SetParamClick(TObject *Sender)
{
      // Установить gamma_c
      ParamChoseSect_Frame1->SetParam(Sender);
      gamma_c_rig = Check_Param.gamma_c_rig;
      gamma_c_kol_outer = Check_Param.gamma_c_kol_outer;
      gamma_c_kol_interior = Check_Param.gamma_c_kol_interior;

      round_h = Param_chosen_sect.round_h;
      round_width = Param_chosen_sect.round_width;

      ind_minimax = Param_chosen_sect.ind_minimax;

      min_tpol = Param_chosen_sect.min_tpol;
      max_tpol = Param_chosen_sect.max_tpol;
      min_tsten = Param_chosen_sect.min_tsten;
      max_tsten = Param_chosen_sect.max_tsten;
      min_bpol = Param_chosen_sect.min_bpol;
      max_bpol = Param_chosen_sect.max_bpol;
      min_hsten = Param_chosen_sect.min_hsten;
      ind_round_thick = Param_chosen_sect.round_thick;

      Sect_ParamFrame1->Visible = false;
      BitBtn_SetParam->Visible = false;
      BitBtn_SetAnalyse->Visible = false;
      BitBtnDone->Visible = false;
      BitBtn_Cancel->Visible = false;
      GroupBox2->Visible = false;

      Height = ParamChoseSect_Frame1->Height + 40;
      Width = ParamChoseSect_Frame1->Width + 20;
      ParamChoseSect_Frame1->BitBtn_Exit->Visible = true;
      ParamChoseSect_Frame1->Top = 6;
      ParamChoseSect_Frame1->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::BitBtn_CloseClick(TObject *Sender)
{
      Close();
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::ToolButtonNoContourClick(
      TObject *Sender)
{
    GeneratorForm->ToolButtonNoContourClick(Sender);

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

void __fastcall TChosenKolonnaForm::ToolButtonBeamDiagramClick(
      TObject *Sender)
{
    GeneratorForm->ToolButtonBeamDiagramClick(Sender);

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



void __fastcall TChosenKolonnaForm::CheckBox_gibClick(TObject *Sender)
{
    if (Param_chosen_sect.ind_gib) {
       Common_rama.index_flex_rigel=1;
    }
    else {
       Common_rama.index_flex_rigel=0;
    }
    if (Add_param_rama.index_result==0) {
      Count_result = 0;
      Count_stress = 0;
    }
}
//---------------------------------------------------------------------------


void __fastcall TChosenKolonnaForm::FormClose(TObject *Sender,
      TCloseAction &Action)
{
   int rc;
   // Ревизия сечений разбивки
   rc = Mesh_SectForm->Reform_Mesh_Sect();
   // Корректировка параметров поперечных ребер
   rc = Edge_ParamForm->Reform_Edge();

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

void __fastcall TChosenKolonnaForm::ToolButton1Click(TObject *Sender)
{
     GeneratorForm->ToolButtonNextSetClick(Sender);
}
//---------------------------------------------------------------------------


void __fastcall TChosenKolonnaForm::ToolButton2Click(TObject *Sender)
{
     GeneratorForm->ToolButtonPrevSetClick(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::ToolButton3Click(TObject *Sender)
{
    GeneratorForm->ToolButtonNextVectorClick(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TChosenKolonnaForm::ToolButton4Click(TObject *Sender)
{
    GeneratorForm->ToolButtonPrevVectorClick(Sender);
}
//---------------------------------------------------------------------------


void __fastcall TChosenKolonnaForm::ParamChoseSect_Frame1BitBtn_AnalyseClick(
      TObject *Sender)
{
       int rc, i, j, i_sect;
       AnsiString sign_section;

       if (ParamChoseSect_Frame1->CheckBox_gib->Checked && Common_rama.index_flex_rigel==0) {
          Common_rama.index_flex_rigel=1;
          Count_stress=0;
          Count_result=0;
       }
       if (!ParamChoseSect_Frame1->CheckBox_gib->Checked && Common_rama.index_flex_rigel==1) {
          Common_rama.index_flex_rigel=0;
          Count_stress=0;
          Count_result=0;
       }

       GeneratorForm->SaveTemp(Sender);
       rc = GetParam();
       if (rc>0) return;
       Ry = MaterProp[Material_Number].sa_tens;
       Rs = 0.58*Ry;                              // Допускаемое напряжение на сдвиг
       Ey = MaterProp[Material_Number].E;

      if (flag_mesh_plate) {
          text="Необходимо выполнить разбиение балочными элементами";
          header="";
          i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONERROR);
          return;
      }
      if (!Length_param.flag_concl) {
          header="Недостаточно данных";
          text="Должны быть назначены коэффициенты расчетных длин конструктивных элементов";
          rc=Application->MessageBox(text.c_str(),
                  header.c_str(),
                  MB_OK | MB_ICONERROR);
          return;        
      }
      Height = GroupBox2->Height + 70;
      Width = GroupBox2->Width + Sect_ParamFrame1->Width + 40;
      GroupBox2->Visible = true;
      Sect_ParamFrame1->Visible = true;
      BitBtn_SetParam->Visible = true;
      BitBtn_SetAnalyse->Visible = true;
      BitBtnDone->Visible = true;
      BitBtn_Cancel->Visible = true;
      ParamChoseSect_Frame1->Visible = false;

      i_sect = 0;
      // Выбор сечений колонн для подбора
      switch (Common_rama.type_rama) {
      case ONE_SPAN_DOWN:
      break;
      case ONE_SPAN_DOUBLE_UP:
        for (i=0; i<6; i++) {
          if (Main_Section[i].local_sect==KOLONNA_LEFT) {
            ChosenSect[i_sect].type_sect=nMAIN_SECT;
            ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=Main_Section[i].local_sect;
            ChosenSect[i_sect].pos_sect=Main_Section[i].pos_sect;
            strcpy(ChosenSect[i_sect].title_sect,Main_Section[i].title_sect);
            sign_section = AnsiString(Main_Section[i].sign_sect)+"-"+AnsiString(Main_Section[i].sign_sect);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[0][0] = Length_param.len_kolXZ[0];
            Add_chosen_param[0][1] = Length_param.len_kolYZ[0];
            Add_chosen_param[0][2] = Length_param.length_kol[0];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_UP;
        n_shift_right_sect = 3;   // сдвиг индексов для основных правых сечений
      break;
      case ONE_SPAN_SINGLE_UP:  //-------- рама-3 --------------------------
        for (i=0; i<5; i++) {
          if (Main_Section[i].local_sect==KOLONNA_LEFT || Main_Section[i].local_sect==KOLONNA_RIGHT) {
            ChosenSect[i_sect].type_sect=nMAIN_SECT;
            ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=Main_Section[i].local_sect;
            ChosenSect[i_sect].pos_sect=Main_Section[i].pos_sect;
            strcpy(ChosenSect[i_sect].title_sect,Main_Section[i].title_sect);
            sign_section = AnsiString(Main_Section[i].sign_sect)+"-"+AnsiString(Main_Section[i].sign_sect);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[i_sect];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[i_sect];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[i_sect];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_UP1;
        n_shift_right_sect = 0;   // сдвиг индексов для основных правых сечений
      break;
      case MANY_SPAN_DOWN:
        for (i=0; i<Number_span-1; i++) {
          if (Common_rama.simm!=true || Add_span[i].x_span + Add_span[i].l_span <= Common_rama.x_konek) {
            if (Add_span[i].type_section!=DVUTAVR) continue;  // тип сечения колонны не двутавр
            ChosenSect[i_sect].type_sect=nSPAN_SECT;
            //ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].index_sect = INDEX_INT;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=KOLONNA_SPAN*(i+1);
			ChosenSect[i_sect].pos_sect=Add_span[i].pos_sect;
			Astr = nameSPAN_KOL_SECT+IntToStr(i+1);
			strcpy(ChosenSect[i_sect].title_sect,Astr.c_str());
            sign_section = AnsiString(Add_span[i].sign_sect_kol+4)+"-"+AnsiString(Add_span[i].sign_sect_kol+4);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[i+2];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[i+2];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[i+2];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_MD_DOWN;
        n_shift_right_sect = 4;   // сдвиг индексов для основных правых сечений
      break;
      case MANY_SPAN_UP:
        for (i=0; i<6; i++) {
          if ((Common_rama.simm && Main_Section[i].local_sect==KOLONNA_LEFT) ||
              (!Common_rama.simm && (Main_Section[i].local_sect==KOLONNA_LEFT || Main_Section[i].local_sect==KOLONNA_RIGHT))  ) {
            if (Main_Section[i].local_sect==KOLONNA_LEFT && Sect_kol_rama5[0].type_section!=DVUTAVR) continue;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT && Sect_kol_rama5[1].type_section!=DVUTAVR) continue;
            ChosenSect[i_sect].type_sect=nMAIN_SECT;
            ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=Main_Section[i].local_sect;
            ChosenSect[i_sect].pos_sect=Main_Section[i].pos_sect;
            strcpy(ChosenSect[i_sect].title_sect,Main_Section[i].title_sect);
            sign_section = AnsiString(Main_Section[i].sign_sect)+"-"+AnsiString(Main_Section[i].sign_sect);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            if (Main_Section[i].local_sect==KOLONNA_LEFT)
               j=0;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT)
               j=1;
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[j];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[j];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[j];
            i_sect ++;
          }
        }
        for (i=0; i<Number_span-1; i++) {
          if (Common_rama.simm!=true || Add_span[i].x_span + Add_span[i].l_span <= Common_rama.x_konek) {
            if (Add_span[i].type_section!=DVUTAVR) continue;  // тип сечения колонны не двутавр
            ChosenSect[i_sect].type_sect=nSPAN_SECT;
            //ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].index_sect = INDEX_INT;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=KOLONNA_SPAN*(i+1);
			ChosenSect[i_sect].pos_sect=Add_span[i].pos_sect;
			Astr = nameSPAN_KOL_SECT+IntToStr(i+1);
			strcpy(ChosenSect[i_sect].title_sect,Astr.c_str());
            sign_section = AnsiString(Add_span[i].sign_sect_kol)+"-"+AnsiString(Add_span[i].sign_sect_kol);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[i+2];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[i+2];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[i+2];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_MANY_UP;
        n_shift_right_sect = 3;   // сдвиг индексов для основных правых сечений
      break;
      case MANY_SPAN_LEVEL:
        for (i=0; i<6; i++) {
          if ((Common_rama.simm && Main_Section[i].local_sect==KOLONNA_LEFT) ||
              (!Common_rama.simm && (Main_Section[i].local_sect==KOLONNA_LEFT || Main_Section[i].local_sect==KOLONNA_RIGHT))  ) {
            if (Main_Section[i].local_sect==KOLONNA_LEFT && Sect_kol_rama5[0].type_section!=DVUTAVR) continue;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT && Sect_kol_rama5[1].type_section!=DVUTAVR) continue;
            ChosenSect[i_sect].type_sect=nMAIN_SECT;
            ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=Main_Section[i].local_sect;
            ChosenSect[i_sect].pos_sect=Main_Section[i].pos_sect;
            strcpy(ChosenSect[i_sect].title_sect,Main_Section[i].title_sect);
            sign_section = AnsiString(Main_Section[i].sign_sect)+"-"+AnsiString(Main_Section[i].sign_sect);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            if (Main_Section[i].local_sect==KOLONNA_LEFT)
               j=0;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT)
               j=1;
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[j];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[j];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[j];
            i_sect ++;
          }
        }
        for (i=0; i<Number_span-1; i++) {
          if (Common_rama.simm!=true || Add_span[i].x_span + Add_span[i].l_span <= Common_rama.x_konek) {
            if (Add_span[i].type_section!=DVUTAVR) continue;  // тип сечения колонны не двутавр
            ChosenSect[i_sect].type_sect=nSPAN_SECT;
            //ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].index_sect = INDEX_INT;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=KOLONNA_SPAN*(i+1);
			ChosenSect[i_sect].pos_sect=Add_span[i].pos_sect;
			Astr = nameSPAN_KOL_SECT+IntToStr(i+1);
			strcpy(ChosenSect[i_sect].title_sect,Astr.c_str());
            sign_section = AnsiString(Add_span[i].sign_sect_kol)+"-"+AnsiString(Add_span[i].sign_sect_kol);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[i+2];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[i+2];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[i+2];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_MANY_UP;
        n_shift_right_sect = 3;   // сдвиг индексов для основных правых сечений
      break;
      case MANY_SPAN_UP_MK:
        for (i=0; i<4; i++) {
          if ((Common_rama.simm && Main_Section[i].local_sect==KOLONNA_LEFT) ||
              (!Common_rama.simm && (Main_Section[i].local_sect==KOLONNA_LEFT || Main_Section[i].local_sect==KOLONNA_RIGHT))  ) {
            if (Main_Section[i].local_sect==KOLONNA_LEFT && Sect_kol_rama5[0].type_section!=DVUTAVR) continue;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT && Sect_kol_rama5[1].type_section!=DVUTAVR) continue;
            ChosenSect[i_sect].type_sect=nMAIN_SECT;
            ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=Main_Section[i].local_sect;
            ChosenSect[i_sect].pos_sect=Main_Section[i].pos_sect;
            strcpy(ChosenSect[i_sect].title_sect,Main_Section[i].title_sect);
            sign_section = AnsiString(Main_Section[i].sign_sect)+"-"+AnsiString(Main_Section[i].sign_sect);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            if (Main_Section[i].local_sect==KOLONNA_LEFT)
               j=0;
            if (Main_Section[i].local_sect==KOLONNA_RIGHT)
               j=1;
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[j];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[j];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[j];
            i_sect ++;
          }
        }
        for (i=0; i<Number_span-1; i++) {
          if (Common_rama.simm!=true || i <= ceil((Number_span - 1)/2)) {
            if (Add_span[i].type_section!=DVUTAVR) continue;  // тип сечения колонны не двутавр
            ChosenSect[i_sect].type_sect=nSPAN_SECT;
            //ChosenSect[i_sect].index_sect=i;
            ChosenSect[i_sect].index_sect = INDEX_INT;
            ChosenSect[i_sect].i_span=0;
            ChosenSect[i_sect].local_sect=KOLONNA_SPAN*(i+1);
            ChosenSect[i_sect].pos_sect=Add_span[i].pos_sect;
			Astr = nameSPAN_KOL_SECT+IntToStr(i+1);
			strcpy(ChosenSect[i_sect].title_sect,Astr.c_str());
			sign_section = AnsiString(Add_span[i].sign_sect_kol)+"-"+AnsiString(Add_span[i].sign_sect_kol);
            strcpy(ChosenSect[i_sect].sign_sect,sign_section.c_str());
            Add_chosen_param[i_sect][0] = Length_param.len_kolXZ[i+2];
            Add_chosen_param[i_sect][1] = Length_param.len_kolYZ[i+2];
            Add_chosen_param[i_sect][2] = Length_param.length_kol[i+2];
            i_sect ++;
          }
        }
        n_main_sect = NUMBER_MAIN_SECT_MANY_UP_MK;
        n_shift_right_sect = 2;   // сдвиг индексов для основных правых сечений
      break;
      default:
         Error_type_rama("ChosenKolonna");
         i_sect=0;
      }
      //ListBoxChosen->MultiSelect=false;

      if (i_sect==0) {
         Close();
         text="В модели нет двутавровых колонн постоянного сечения ";
         header="Выполнение команды прекращается";
         i=Application->MessageBox(text.c_str(), header.c_str(), MB_OK | MB_ICONINFORMATION);
         return;
      }
      // Сортировка стыков
      SortJoint(i_sect,ChosenSect);

      // Заполнение списка
      ListBoxChosen->Clear();
      for (i=0; i<i_sect; i++) {
           ListBoxChosen->Items->Add((AnsiString)ChosenSect[i].title_sect+
                                     " ("+(AnsiString)ChosenSect[i].sign_sect+")");
      }
      ListBoxChosen->ItemIndex=0;
      ListBoxChosen->Selected[0]=true;
      // построить список элементов
      SetElem_in_Sect();

      Sect_ParamFrame1->Check_Original();  // Установка поля рисования сечения
      Sect_ParamFrame1->Label_Sect->Caption = ListBoxChosen->Items->Strings[0];

      //Sect_ParamFrame1->Button_Copy->Visible = false;
      Sect_ParamFrame1->Button_Geom->Visible = false;

      BitBtn_Return->Enabled = false;
      //Sect_ParamFrame1->Button_Apply->Enabled=false;
     // BitBtn_ChoiceSelect->Enabled=false;
      Label_Mz->Caption="";
      Label_Nx->Caption="";
      Label_Qy->Caption="";
      Label_Comb->Caption="";

      /*
      if (flag_simm==true)
         Sect_ParamFrame1->Label_Side->Caption="";
      else
         Sect_ParamFrame1->Label_Side->Caption="Левая сторона";

      sect = &(Main_Section[0].section);

      Sect_ParamFrame1->Write_sect(Sender);

      flag_sect_change=false;
      */
      ChangeSect(Sender);
      rc = Call_Static(true, Sender);
      if (rc>0) {
         BitBtn_CancelClick(Sender);
      }
      if (flag_choose_kol_visible_next_step!=true) {
          flag_choose_kol_visible_next_step=true;
          Close();
      }

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

void __fastcall TChosenKolonnaForm::ParamChoseSect_Frame1BitBtn_ExitClick(
      TObject *Sender)
{
      int rc;
      rc = GetParam();

      Height = GroupBox2->Height + 70;
      Width = GroupBox2->Width + Sect_ParamFrame1->Width + 40;
      GroupBox2->Visible = true;
      Sect_ParamFrame1->Visible = true;
      BitBtn_SetParam->Visible = true;
      BitBtn_SetAnalyse->Visible = true;
      BitBtnDone->Visible = true;
      BitBtn_Cancel->Visible = true;
      ParamChoseSect_Frame1->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TChosenKolonnaForm::ParamChoseSect_Frame1BitBtn_CloseClick(
      TObject *Sender)
{
      Close();        
        
}
//---------------------------------------------------------------------------

void __fastcall TChosenKolonnaForm::ParamChoseSect_Frame1CheckBox_gibClick(
      TObject *Sender)
{
  ParamChoseSect_Frame1->CheckBox_gibClick(Sender);

}
//---------------------------------------------------------------------------
#include "ChosenKolonna%ChoiseKolonna_Alg0.cpp"
