/*------------------------------------------------------------------*/
/*                       типы данных генерации                      */
/*------------------------------------------------------------------*/

#ifndef tdata_genH                 
#define tdata_genH

#include <vcl.h>
#include "Alinit.h"
#include "TypeData.h"

#define MAXPOINT            10000   // максимальное число точек
#define MAX_ADD_SECT        1000    // максимальное число дополнительных сечений
#define MAX_EDGE            500    // максимальное число ребер жесткости
#define MAX_MAIN_SECT       500    // максимальное число основных сечений
#define MAX_BASE_POINT      500    // максимальное число базовых точек, определяющих геометрию рамы
#define MAX_ADD_SPAN        50     // максимальное число пролетов
#define MAX_ARBIT_LOAD      100     // максимальное число произвольных загружений (было 50)
#define MAX_PLAN_LOAD       500     // максимальное число участков нагружений
#define MAX_MACRO           10000   // максимальное число поверхностей
#define MAX_PLAN_CONSTRAINT 50
#define MAX_RESULT          1000
#define SIZE_NAME_RESULT    121
#define MAX_LOAD_SET        150    // максимальное число вариантов нагружений   ( было 100)

#define SIZE_VAR_NAME       1200   // Максимальный размер имени комбинации
#define MAX_VAR_SET         150    // максимальное число вариантов в комбинации

//#define SIZE_VAR_NAME       50   // Максимальный разиер имени комбинации
//#define MAX_VAR_SET         50    // максимальное число вариантов в комбинации

#define MAXG_POINT          1000    // максимальное количество точек в геометрии
#define MAXG_LINE           1000    // максимальное количество линий (конструктивных элементов)

#define ONE_SPAN_DOWN       0
#define ONE_SPAN_DOUBLE_UP  1
#define ONE_SPAN_SINGLE_UP  2
#define MANY_SPAN_DOWN      3
#define MANY_SPAN_UP        4
#define MANY_SPAN_UP_MK     5
#define ARBIT_RAMA          6      // Произвольная рама
#define SEGMENT_RAMA        7
#define MANY_SPAN_LEVEL     8      // многоуровневая рама
#define ARBIT_UNIT          9

#define MAX_JOINT          500
#define MAX_SELECT         10000    // максимальное число выбираемых элементов
#define NSIGN              134       // число символов для сечений
#define SIGN_SECT "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЬЫЭЮЯABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%&*абвгдеёжзийклмнопрстуфхцчшщъьыэюяabcdefghijklmnoqprstuvwxyz"

#define MAX_CRAN_PARAM  50     // максимальное количество кранов
#define MAX_CRAN_LOAD   180     // максимальное количество крановых нагрузок
#define MAX_CRAN_COMB   30      // максимальное количество сочетаний кранов

#define NUMBER_MAIN_SECT_DOWN          11
#define NUMBER_MAIN_POINT_DOWN         16

#define NUMBER_MAIN_SECT_UP            9
#define NUMBER_MAIN_SECT_UP1           7
#define NUMBER_MAIN_SECT_MD_DOWN       11
#define NUMBER_MAIN_SECT_MANY_UP       9
#define NUMBER_MAIN_SECT_MANY_UP_MK    6
#define NUMBER_MAIN_SECT_SEGMENT       3
#define NUMBER_MAIN_SECT_MANY_LEVEL    9

#define NO_CHOISE          0
#define DVUTAVR            1
#define SQUARE_TUBE        2
#define RECT_TUBE          3
#define CIRCULAR_TUBE      4
#define RECTANCULAR        5
#define SHVELLER           6
#define CHANNEL            6
#define TAVR               7
#define CORNER_TWO         9
/*
#define GNU_CH             10
#define GNU_C              11
#define GNU_Z              12
#define GNU_ZC             13
#define GNU_SIGMA          14
*/
#define TAVR_UP            15    // для проверок
#define TAVR_DOWN          16
#define CORNER_ONE         17


#define EDGE_DOUBLE_ALL    1
#define EDGE_SINGLE_ALL    2
#define EDGE_DOUBLE_COM    3
#define EDGE_SINGLE_COM    4

#define COLOR      clMedGray
#define COLOR_EDGE clScrollBar
#define SPACE_EDGE 40

#define NULL_SECT         -2   // признак конца списка сечений
#define nMAIN_SECT         0
#define nADD_SECT          1
#define nMESH_SECT         2
#define nEDGE_SECT         3
#define nSPAN_SECT         4  // сечения ригеля над средними колоннами
#define nSPAN_KOL_SECT     5  // сечение средних колонн
#define nSPAN_SECT_MK      6  // сечение ригеля в многоконьковой раме
#define nSPAN_SECT_MK0     7  // сечение ригеля над средними колоннами в многоконьковой раме
#define nLEVEL_SECT        8  // сечение на балке уровня
#define nMASS              9  // сосредоточенные массы
#define nPODSTROP_BALKA    10  // сечение подстропильной балки

#define CRAN_CONSOL_RIGHT   -4
#define CRAN_CONSOL_LEFT    -3
#define ZATYAGHKA     -2
#define MAIN_SECT     -1   // индекс расположения сечения для основных сечений
#define KOLONNA_LEFT   0   // индексы расположения дополнительных сечений
#define RIGEL_LEFT     1
#define KOLONNA_RIGHT  2
#define RIGEL_RIGHT    3
#define KOLONNA_RIGEL_LEFT         4
#define KOLONNA_RIGEL_RIGHT        5
#define KOLONNA_RIGEL_LEFT_KOL     6
#define KOLONNA_RIGEL_LEFT_RIG     7
#define KOLONNA_RIGEL_RIGHT_KOL    8
#define KOLONNA_RIGEL_RIGHT_RIG    9
#define KONEK                     10
#define KOLONNA_SPAN              11
#define CONSTR_ELEMENT            12   // конструктивный элемент, используется для идентификации
                                       // принадлежности конечного элемета к конструктивному элементу
#define SEGMENT_SECT              13
#define SEGMENT_AT_LEFT           14
#define SEGMENT_AT_RIGHT          15
#define SEGMENT_MAIN_LEFT         16
#define SEGMENT_MAIN_RIGHT        17
#define LEVEL_SECT                18
#define STRET_FACHWERK            19

#define KOLONNA_LEFT_MACRO        20   // индексы расположения сечений
#define RIGEL_LEFT_MACRO          21   // индексы расположения сечений
#define KOLONNA_RIGHT_MACRO       22   // индексы расположения сечений
#define RIGEL_RIGHT_MACRO         23   // индексы расположения сечений
#define KOLONNA_LEFT_MACRO_0      24   // индексы расположения сечений
#define RIGEL_LEFT_MACRO_0        25   // индексы расположения сечений
#define KOLONNA_RIGHT_MACRO_0     26   // индексы расположения сечений
#define RIGEL_RIGHT_MACRO_0       27   // индексы расположения сечений
#define BALKA_PODSTROP            28

#define ONE_SPAN_DOWN_NAME  "Однопролетная рама. Моментное сопряжение ригеля с колоннами"
#define ONE_SPAN_UP_NAME    "Однопролетная двускатная рама. Шарнирное сопряжение ригеля с колоннами"
#define ONE_SPAN_1_UP_NAME  "Однопролетная односкатная рама. Шарнирное сопряжение ригеля с колоннами"
#define MANY_SPAN_DOWN_NAME "Многопролетная, одноконьковая рама. Смешанное сопряжение ригеля с колоннами"
#define MANY_SPAN_UP_NAME   "Многопролетная, одноконьковая рама. Шарнирное сопряжение ригеля с колоннами"
#define MANY_SPAN_UP_MK_NAME   "Многопролетная, многоконьковая рама. Шарнирное сопряжение ригеля с колоннами"
#define ARBIT_RAMA_NAME   "Рама произвольного типа"
#define SEGMENT_RAMA_NAME   "Однопролетная сегментная рама"
#define MANY_LEVEL_NAME   "Многопролетная, одноконьковая, многоэтажная рама"

#define nameSTYK_LEFT_KOL   "Левая колонна в стыке с ригелем"
#define nameSTYK_RIGHT_KOL  "Правая колонна в стыке с ригелем"
#define nameSTYK_LEFT_RIG   "Левый ригель в стыке с колонной"
#define nameSTYK_RIGHT_RIG  "Правый ригель в стыке с колонной"
#define nameSTYK_LEFT   "Стык левых ригеля и колонны"
#define nameSTYK_RIGHT  "Стык правых ригеля и колонны"
#define nameKONEK       "Конек"
#define nameSPAN_KOL_SECT    "Внутренняя колонна "
#define nameBALKA_PODSTROP   "Подстропильная балка "

#define nameLOCAL       "Колонна лев ","Ригель лев  ","Колонна прав","Ригель прав ", "            ", " ", " ", " ", " ", " ", "Конек       "," ",\
                        "Сегмент", "Сегмент, стык слева", "Сегмент, стык справа", "Сегмент, осн.сеч. слева", "Сегмент, осн.сеч. справа", \
                        " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "

#define nameTYPE        "Основное    ","Дополнит    ","            ","Ребро       ", "Риг_над_сред", " ", "Риг_в коньке", "Риг_над_средMK", " ", " ", " ", " ",\
                        "Основное    ","Ребро       ","Ребро       ","Ребро       ","Ребро       "

// номера основных сечений рамы-1
#define R1_NIZ_KOL_LEFT     0
#define R1_VERH_KOL_LEFT    1
#define R1_RIG_LEFT         2
#define R1_RIG_KONEK_LEFT   3
#define R1_NIZ_KOL_RIGHT    4
#define R1_VERH_KOL_RIGHT   5
#define R1_RIG_RIGHT        6
#define R1_RIG_KONEK_RIGHT  7
#define R1_STYK_LEFT        8
#define R1_KONEK            9
#define R1_STYK_RIGHT      10

#define BODY                0
#define CONST_LOAD          1
#define SNOW_LEFT           2
#define SNOW_RIGHT          3
#define WIND_LEFT           4
#define WIND_RIGHT          5

#define FORCE               0
#define FORCE_PER_LENGTH    1
#define FORCE_PER_AREA      2
#define MOMENT              3

#define dirCOMPONENTS       0
#define dirALONG            1
#define dirNORMAL           2
#define dirVECTOR           3

#define methUNIFORM         0
#define methTAPER           1
#define methFORCE           0
#define methSNOWREGION      1
#define methWINDREGION      2
#define methFORCE_CRAN      3  // Вертикальная сосредоточенная сила крановой нагрузки


#define colorNODE           'n'
#define colorELEM           'e'
#define colorLOAD_GEOM      'f'
#define colorLOAD_KEM       'k'
#define colorCONSTRAINT     'c'
#define colorORIGIN         'o'
#define colorAXIS           'a'
#define colorGEOM           'g'
#define colorGEOM_POINT     't'
#define colorGEOM_LINE      'r'
#define colorLABEL          'l'
#define colorLABEL_H        'h'
#define colorLABEL_POS      'p'
#define colorLABEL_ANGLE    'u'
#define colorPIN            'b'
#define colorMASS           'm'
#define colorWINDOW         'w'
#define colorSHADOW         's'

#define indCREATE           0
#define indMODIFY           1
#define indDELETE           2
#define indRELOAD           3

#define indUN_WEIGHT        0    // не учитывать плотность
#define indWEIGHT           1    // учитывать плотность

#define opNULL              ' '
#define opPLUS              '+'
#define opMINUS             '-'
#define opMULT              '*'
#define opDIVIDE            '/'

#define LEN_NAME  47    // длина имени рамы в структуре общих данных
#define MAX_LEN_ARR 80  // длина стрелки

#define Load_CNIP  0  //СНиП 2.01.07-85*, 1 - СП 20.13330.2011
#define Load_SP    1  //СНиП 2.01.07-85*, 1 - СП 20.13330.2011

// Классификация элементов по виду напряженного состояния
#define   groupNON_DEFINED    0   //  не определена, должна определяться автоматически
#define   groupCENT_COMP      1   //  центрально-сжатые
#define   groupBEND_COMP      2   //  сжато-изгибаемые элементы
#define   groupBEND           3   //  изгибаемые элементы
#define   groupCENT_TENS      4   //  центрально-растянутые элементы
#define   groupBEND_TENS      5   //  растянуто-изгибаемые элементы


typedef struct _preferences {
   double max_size_plate;
   double max_size_beam;
   int    n_elem_pol;
   int    n_elem_sten;
   char   PathWork[196];  // Путь к рабочей папке SCAD
   char   index_DelSectMesh;   // 0 - удалять, -1 - не удалять
   char   index_round_thick;
   char   CharDummy[2];
   double Tolerance;
   double Del_Merge;
   double dummy[3];
}  PREFERENCES;

typedef struct _vector {
   double Base_x;
   double Base_y;
   double Base_z;
   double Tip_x;
   double Tip_y;
   double Tip_z;
}  VECTOR;

typedef struct _sect_dvutavr {
   double b;      // толщина стенки двутавра
   double h;      // высота стенки двутавра
   double b1;     // ширина наружной полки двутавра
   double h1;     // толщина внутренней полки двутавра
   double b2;     // ширина наружной полки двутавра
   double h2;     // толщина внутренней полки двутавра
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0 (в плоскости XZ) или 1 (в плоскости YZ)
   char   type_profil;  // или двутавр (DVUTAVR) , или гнутик
   char   index_perfor;  // 0 - не перфорированный двутавр, 1 - перфорированный
   char   dummy[2];
   float  fG;
   float  tnom;    // Номинальная толщина с учетом всех покрытий
   float  b2G;     // Ширина нижней полки гнутика
   float  gG;    //
   bool flag_concl;
}  SECT_DVUTAVR;

typedef struct _sect_gnutic {
   double tG;      // толщина стенки (стали)
   double hG;      // высота гнутика
   double bG;      // ширина полки
   double cG;      // высота отгиба
   double rG;      // радиус скругления
   double jG;      // ширина выштамповки
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0 (в плоскости XZ) или 1 (в плоскости YZ)
   char   type_profil;  // или двутавр (DVUTAVR) , или гнутик
   char   index_perfor;  // 0 - не перфорированный двутавр, 1 - перфорированный
   char   index_paired;  // 0 - не спаренный; 1- спаренный
   char   dummy;
   float  fG;      // Глубина выштамповки
   float  tnom;    // Номинальная толщина с учетом всех покрытий
   float  b2G;     // Ширина нижней полки гнутика
   float  gG;      // высота наклонного ребра
   bool flag_concl;
}  SECT_GNUTIC;

typedef struct _sect_square {
   double thickness;  // толщина стенок
   double side;       // размер стороны
   double b1;   // не используется
   double h1;   // не используется
   double b2;   // не используется
   double h2;   // не используется
   int    n_group;   // номер группы профилей - определяет h*b
   int    n_profil;  // номер профиля в группе - определяет t
   int    index_orient;   // ориентация = 0
   char   type_profil;
   char   dummy_c[3];
   float rad;
   float t_red;
   float dummy_f[2];
   bool flag_concl;
}  SECT_SQUARE;

typedef struct _sect_rect {
   double b;      // ширина сечения
   double h;      // высота сечения
   double b1;     // толщина стенок по ширине
   double h1;     // толщина стенок по высоте
   double b2;     // не используется
   double h2;     // не используется
   int    n_group;   // номер группы профилей - определяет h*b
   int    n_profil;  // порядковый номер профиля в группе - определяет t
   int    index_orient;   // ориентация: 0 - по высоте; 1 - по ширине
   char   type_profil;
   char   dummy_c[3];
   float rad;
   float t_red;
   float dummy_f[2];
   bool flag_concl;
}  SECT_RECT;

typedef struct _sect_rect_solid {
   double b;      // ширина сечения
   double h;      // высота сечения
   double b1;     // не используется
   double h1;     // не используется
   double b2;     // не используется
   double h2;     // не используется
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0
   char   type_profil;
   char   dummy_c[3];
   float dummy_f[4];
   bool flag_concl;
}  SECT_RECT_SOLID;

typedef struct _sect_circ {
   double thickness;  // толщина стенки
   double diameter;   // диаметр
   double b1;         // не используется
   double h1;         // не используется
   double b2;         // не используется
   double h2;         // не используется
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0
   char   type_profil;
   char   dummy_c[3];
   float t_red;
   float  dummy_f[3];
   bool flag_concl;
}  SECT_CIRC;

typedef struct _sect_corner_two {
   double bx;      // Размер полки по X
   double by;      // Размер полки по Y
   double t;       // толщина стенки
   double x0;      // расстояние от верхней грани до ц.т.
   double y0;      // расстояние от боковой грани до ц.т.
   double b2;      // не используется
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0
   char   type_profil;
   char   index_equ;   // 0 - равнополочный; 1 - неравнополочный
   char   index_bend;   // 0 - не гнутый; 1 - гнутый
   char   index_top;    // 0 - T, 1 - X расположение; 2 - одинарный уголок
   float  fG;         // расстояние между уголками тавра
   float Rad;
   float rad;
   float dummy_f;
   bool flag_concl;
}  SECT_CORNER_TWO;


typedef struct _sect_channel {
   double b;      // толщина стенки швеллера
   double h;      // высота стенки швеллера
   double b1;     // ширина наружной полки швеллера
   double h1;     // толщина наружной полки швеллера
   double b2;     // ширина внутренней полки швеллера
   double h2;     // толщина внутренней полки швеллера
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0 (в плоскости XZ) или 1 (в плоскости YZ)
   char   type_profil;    // CHANNEL
   char   index_bend;     // 0 - прокатной, 1 - гнутый
   char   index_slope;
   char   dummy;
   float  fG;
   float  Rad;     // Ширина нижней полки гнутика
   float  rad;    //
   float  z0;
   bool flag_concl;
}  SECT_CHANNEL;

typedef struct _sect_tavr {
   double b;      // толщина стенки тавра
   double h;      // высота стенки тавра
   double b1;     // ширина наружной полки тавра
   double h1;     // толщина наружной полки тавра
   double b2;     // ширина внутренней полки тавра = 0
   double h2;     // толщина внутренней полки тавра = 0
   int    n_group;   // номер группы профилей
   int    n_profil;  // номер профиля в группе
   int    index_orient;   // ориентация = 0 (в плоскости XZ) или 1 (в плоскости YZ)
   char   type_profil;    // TAVR
   char   dummy_c[3];
   //float  fG;
   float  dummy[2];    // Номинальная толщина с учетом всех покрытий
   float  Rad;     //
   float  y0;      // расстояние до ц.т
   bool flag_concl;
}  SECT_TAVR;

typedef union _common_sect {   // Обобщенные данные о сечении
   SECT_DVUTAVR dvutavr;
   SECT_SQUARE  square;
   SECT_RECT    rect;
   SECT_CIRC    circ;
   SECT_RECT_SOLID rect_solid;
   SECT_CORNER_TWO  corner_two;  // тавр из двух уголков
   SECT_TAVR    tavr;   // тавр
   SECT_CHANNEL channel;  // швеллер
   SECT_GNUTIC  gnutic;  // гнутик
}  COMMON_SECT;

typedef struct _data_sect_scad {   // Обобщенные данные о сечении элемента
   int  type_sect;
   COMMON_SECT com_sect;
}  DATA_SECT_SCAD;

typedef struct _comgen_new {  // общие данные о раме
   char   name_rama[48];
   int    type_rama;          // тип рамы (ONE_SPAN_DOWN, ONE_SPAN_DOUBLE_UP, ONE_SPAN_SINGLE_UP, MANY_SPAN_DOWN, MANY_SPAN_UP
   bool   simm;               // признак симметрии рамы
   double span;               // пролет
   double x_konek;            // координата конька X
   double z_konek;            // координата конька Z
   double left_kolonna;       // привязка внешней грани левой колонны
   double left_z_rigel;       // отметка низа левого ригеля
   double left_z_kolonna;     // отметка низа левой колонны
   double left_uklon;         // уклон левого ригеля в %
   double right_kolonna;
   double right_z_rigel;
   double right_z_kolonna;
   double right_uklon;
   double step_rama;          // шаг рам;
   int n_main_sect;           // число основных сечений
   int n_add_sect;            // число дополнительных сечений
   char index_profil_rigel;
   char index_profil_kolonna;
   char index_profil_segment;
   char index_profil_kolonna_inter;
   char index_fachwerk;       // 1 - фахверк, 0 или любое число - не фахверк 
   char dummy_char[3];
   short dummy_short;
   short n_macro;
   char flag_auto_pin;
   char flag_auto_constr;
   short n_group_sect;        // число групп сечений
   int n_edge;                // число ребер жесткости
   int n_mesh_sect;           // число дополнительных линий разбивки
   char n_arbit_load;         // число произвольных вариантов нагружений
   char n_cran;               // число кранов
   char n_cran_comb;          // число сочетаний кранов
   char n_cran_load;          // число крановых вариантов нагружений
   char cent_lean[4];         // признак центрального опирания ригеля на колонны рам 2,3,5 типа: "СЕNT"
   double zat_a_b[2];         // параметры затяжки. Если zat_a_b[0]<=0 - затяжку не включать, a=ABS(zat_a_b[0])
   double gamma_n;            // коэффициент надежности по ответственности
   char index_flex_rigel;     // ригель - балка с гибкой стенкой (1), нет - 0 или другое число
   char  index_pattern_main;  // 1: сновные сечения не заданы - макет, 0: основные сечения заданы
   char n_tipical_load;       // число типовых нагрузок
   char index_Load_and_Action;  // 0 - СНиП 2.01.07-85*, 1 - СП 20.13330.2011
   short n_edge_left;         // число ребер на левой колонне постоянного сечения
   short n_edge_right;        // число ребер на правой колонне постоянного сечения
}  COM_RAMA;

typedef struct _add_param_rama {  // дополнительные параметры рам
   double  Shift_opora;            // сдвиг левой опоры относительно разбивочной оси: shift > 0 - сдвиг вовнутрь
   double  Shift_opora_right;      // сдвиг правой опоры относительно разбивочной оси: shift > 0 - сдвиг вовнутрь
   char    release_rig[16];            // тип сопряжения ригелей [0] - 0 и 1 пролета, [1] - 1 и 2 пролета, и т.д. 0 - жесткое, 1 - шарнирное
   char    release_kol[16];            // тип сопряжения средних колонн с фундаментом [0] - 0 и 1 пролета, [1] - 1 и 2 пролета, и т.д. 0 - жесткое, 1 - шарнирное
   int     n_long_edge;                // число продольных ребер жесткости
   bool    flag_lock;                  // флаг запрещения изменений расчетной модели
   bool    flag_fileScad;              // флаг установки файла SCAD
   short   index_result;               // индекс результатов (0 - Гепард, 1 - SCAD)
   short   nnuz_origin;
   short   nnel_origin;
   short   gran;                         // 0 - уклон колонн по внешней грани; 1 - уклон по внутренней грани
   bool    flag_hing_kol_rig;          // флаг шарнирного сопряжения ригеля с крайними колоннами
   bool    flag_single_uklon;          // флаг односкатной рамы
   double  left_kol_uklon;             // уклон левой колонны рамы-1 в % от вертикали (>0 - внутрь)
   double  right_kol_uklon;            // уклон правой колонны рамы-1 в % от вертикали (>0 - внутрь)
   bool    flag_kol_level[16];         // true - колонна не доходит до ригеля, false - доходит
}  ADD_PARAM_RAMA;

typedef struct _add_span {    // данные о пролетах
   char   sign_sect_kol[8];   // обозначение сечения колонны
   char   sign_sect_rig[8];   // обозначение сечений ригеля
   double x_span;           // привязка левой оси пролета
   double l_span;           // размер пролета
   double z_kolonna;        // отметка низа колонны
   double pos_sect;         // позиция сечения (вычисляется в Get_base_sect_MD_plate и в Mesh_planP_ManyDown)
   int type_section;        // тип сечения колонны
   int    n_edge;           // количество ребер
   double b_edge;           // ширина выступающей части ребер
   float  t_edge;           // толщина ребер
   short  type_edge;        // тип ребер
   short  group_sect;       // номер группы для сечения ригеля
   COMMON_SECT sect_kol;    // данные о сечении колонны (тип - определен флагом type_section)
   COMMON_SECT sect_rig;    // данные о сечении ригеля по оси колонны (тип - dvutavr)
}  ADD_SPAN;

typedef struct _add_span_mk {  // данные о пролетах многоконьковой рамы и одноконьковой рамы также (с 27.08.2011)
   char   sign_sect_konek[8];  // обозначение сечений ригеля в коньке
   double x_konek;             // привязка конька относительно левой оси пролета
   double pos_konek;           // позиция сечения конька
   double left_uklon;          // уклон левой части ригеля
   double right_uklon;         // уклон правой части ригеля
   double z_up_kolonna;        // отметка верха колонны
   double pos_left;            // позиция сечения слева от конька
   double pos_right;           // позиция сечения справа от конька
   int    index_right;         // индекс задания высоты колонны или уклона справа от конька (0 или 1)
   short  group_sect;
   short  short_dummy;
   double dummy[3];
   SECT_DVUTAVR sect_konek;      // данные о сечении ригеля слева от конька (тип - dvutavr)
}  ADD_SPAN_MK;

typedef struct _data_sect {   // Данные о главных и дополнительных сечениях
   char     title_sect[34];
   short    type_section;     // тип сечения (DVUTAVR, ...
   short    i_span;
   short    i_level;
   char     sign_sect[8];
   short    local_sect;   // расположение сечения - на колонне или на ригеле
   short    group_sect;   // номер группы, в которую входит сечение, или -1
   double pos_sect;       // привязка сечения
   SECT_DVUTAVR section;
}  DATA_SECT;

typedef struct _data_sect_com {   // Данные о сечении общего вида
   char   title_sect[36];
   short  i_span;
   short  i_level;
   char   sign_sect[8];
   short    local_sect;   // расположение сечения - на колонне или на ригеле
   short    group_sect;   // номер группы, в которую входит сечение, или -1
   double pos_sect;     // привязка сечения
   int type_section;        // тип сечения колонны
   COMMON_SECT section;
}  DATA_SECT_COM;

typedef struct _data_edge {   // Данные о ребрах
   char title_sect[36];
   int  dummy[2];
   short  i_span;
   short  i_level;
   bool flag_concl;
   bool flag_double;      // флаг двустороннего ребра: true - двустороннее
   bool flag_all;         // флаг ребра на всю высоту: true - ребро на всю высоту
   int    local_sect;     // расположение ребра - на колонне или на ригеле
   int    pos_common;     // расположение ребра общего положения - примыкание к верхней полке (0) или к нижней (1)
   int    pos_single;     // расположение одностороннего ребра - наружная стенка Y>0 (0) или внутренняя Y<0 (1)
   double pos_sect;       // привязка сечения
 // double h1;             // толщина полки 1 в сечении ребра
   double h_stenki;       // высота стенки балки в сечении ребра
 //  double h2;             // толщина полки 2 балки в сечении ребра
   double b_edge;
   double t_edge;
   double h_edge;
   float  pos_edge_norm;  // привязка поперечного ребра на диагональном ребре
   float  t_pop;          // толщина поперечного ребра
}  EDGE_PARAM;

typedef struct _data_long_edge {   // Данные о продольных ребрах
   char title_sect[36];
   int  dummy[2];
   short  i_span;
   short  i_level;
   bool flag_concl;
   bool flag_double;      // флаг двустороннего ребра: true - двустороннее
   bool flag_all;         // флаг ребра на всю высоту: true - ребро на всю высоту
   int    local_sect;     // расположение ребра - на колонне или на ригеле
   int    index_polka;      // параллельно наружной полке (0), или внутренней (1)
   int    index_single;     // расположение одностороннего ребра - наружная стенка Y>0 (0) или внутренняя Y<0 (1)
   double pos_polka;       // привязка относительно внутренней поверхности полки (наружной или внутренней)
   int    index_pos_left;  // индекс привязки слева (-1 если не используется, либо KOLONNA_RIGEL_LEFT_RIG || KOLONNA_RIGEL_RIGHT_RIG)
   int    index_pos_right; // индекс привязки слева (-1 если не используется, либо KOLONNA_RIGEL_LEFT_KOL || KOLONNA_RIGEL_RIGHT_KOL)
   double pos_sect1;      // привязка начала ребра
   double pos_sect2;      // привязка конца ребра
   double length;         // длина ребра
   double b_edge;         // ширина ребра
   double t_edge;         // толщина ребра
}  LONG_EDGE_PARAM;
//#define KOLONNA_RIGEL_LEFT_KOL     6
//#define KOLONNA_RIGEL_LEFT_RIG     7
//#define KOLONNA_RIGEL_RIGHT_KOL    8
//#define KOLONNA_RIGEL_RIGHT_RIG    9

typedef struct _data_mesh_sect {   // Данные о сечениях разбивки
   char   title_sect[36];
   int    dummy[2];
   short    i_span;
   short    i_level;
   bool   flag_concl;
   int    local_sect;     // расположение сечения - на колонне или на ригеле
   double pos_sect;       // привязка сечения
   double h_stenki;       // высота стенки балки в сечении ребра
}  MESH_SECT_PARAM;


typedef struct _pos_sect {  // позиции сечений рамы
   //char title[48];
   //int local;
   //double pos;
   int    n_type_sect;      // номер подмножества сечений
   int    ID_sect;          // номер сечения в подмножестве
   int    k_sect;           // номер сечения в point_corners
}  POS_SECT;


typedef struct _option_draw {  // опции вывода
   int    node [3];    // [0]- 0/1 (не рисовать/рисовать) [1] - 0/1 (без номера/с номером) [2] -0/1 (непрозр/прозр)
   int    element[3];
   int    load_geom[3];
   int    load_kem[3];
   short  constraint[3];
   short  pin[3];
   short  geometry[4];
   char   mass[3];
   char   send_mark;
   short  geom_point[3];
   short  geom_line[3];
   short  origin[3];
   short  axis[3];
   char  cl_node[3][16];
   char  cl_element[3][16];
   char  cl_load_geom[3][16];
   char  cl_load_kem[3][16];
   char  cl_constraint[3][16];
   char  cl_origin[3][16];
   char  cl_axis[3][16];
   char  cl_geometry[3][16];
   char  cl_label[3][16];
   char  ind_Render;
   char  ind_Volume;
   TColor   cl_shadow[2];
   int   dummy_int[6];
   short  label_H[2];
   short  label_pos[3];
   short  label_Prolet[3];
   short  label_Angle[3];
   short  title_result[3];    // заголовок результатов
   short  scale_contour[3];   // шкала результатов
   char cl_label_H[3][16];
   char cl_label_pos[3][16];
   char cl_deformed[3][16];
   char cl_label_Angle[3][16];
   char  cl_geom_point[1][16];
   char  cl_pin[2][16];
   char  cl_geom_line[1][16];
   char  cl_mass[2][16];
   char cl_window[16];
}  OPTION_DRAW;


#define LOAD_CONTROL           2.08
typedef struct _data_load_set  {// Данные о типовых нагрузках

   double karniz;               // размер карниза
   double parapet;              // размер парапета
   double vert_kol;             // вертикальная нагрузка на колонны
   double vert_rig;             // вертикальная нагрузка на ригеля
   double average_temp;         // средняя температура января
   int snow_region;             // снеговой регион
   int wind_region;             // ветровой регион
   int type_region;             // тип местности
   double Level_ground;         // уровень земли отн. 0.0
   double gamma_f;              // коэффициент надежности по ветровой нагрузке
   float  freq_1;               // первая собственная частота
   float  freq_2;               // вторая собственная частота
   double koeff_snow;           // коэффициент увеличения снеговой нагрузки
   short  index_PerLength;
   char  group_excl_snow;      // группа исключений для снеговой нагрузки сегментной рамы и (для углов больше 20 град?)
   bool  flag_Sg;              // флаг произвольного задания снеговой нагрузки
   float  pos_torec;            // Позиция рамы относительно торца здания
   double gamma_f_g;            // коэффициент надежности по нагрузке от собственного веса
   double gamma_f_c;            // коэффициент надежности по постоянной нагрузке
   double gamma_f_s;            // коэффициент надежности по снеговой нагрузке
   double koeff_snow_def;       // Коэффициент понижения снеговой нагрузки для расчета ригеля по деформациям
   short  n_const_level;
   short  n_add_const_level;
   short  n_const_level_res;
   short  index_torec_wind;     // действие ветровой нагрузки 0 - в оба торца, 1 - на передний, 2 - на задний (СП)
   double gamma_f_l;            // коэффициент надежности по постоянной нагрузке на уровни
   short  n_add_const;          // количество дополнительных нагрузок в векторе постоянных нагрузок
   short  n_add_snow_left;      // количество дополнительных нагрузок в векторе снеговых нагрузок слева
   short  n_add_snow_right;     // количество дополнительных нагрузок в векторе снеговых нагрузок справа
   short  index_const_load;     // Прикладывать (0) или нет (1) постоянную нагрузку
   bool   flag_w0;              // Использовать заданное нормативное значение ветрового давления w0
   bool   puls_var;             // вариант учета пульсационной составляющей 0 - без учета частот, 1 - с учетом частот
   short  const_BL;             // Отношение ширины здания к длине;               //
   short  index_koeff_ce;       // индекс учета сноса снега (0 - не учитывать, 1 учитывать)
   short  index_kol_wind;       // действие ветровой нагрузки 0 - на обе колонны, 1 - на левую, 2 - на правую
   double koeff_weight;         // от веса - ускорения по осям: koeff + gx, gy, gz  по умолчанию (-1.2, 0,0, 9810) (вес=масса*ускорение свободного падения).
   float  delta_h;              // Delta_h для определения h
   float koeff_ct;
   float V_cold;
   float d_size;                // поперечный размер здания (мм)
   float w0;                    // заданное нормативное значение ветрового давления
   float Sg;                    // заданное значение снеговой нагрузки
   short n_const;               // длина вектора постоянных нагрузок
   bool  flag_reduce_snow;      // флаг принятого пониженного коэффициента снеговой нагрузки
   bool  flag_puls;             // учет пульсационной сотавляющей
   short n_snow_left;             // длина вектора снеговых нагрузок слева
   short n_snow_left_res;             // длина вектора снеговых нагрузок слева
   short n_snow_right;            // длина вектора снеговых нагрузок справа
   short n_snow_right_res;            // длина вектора снеговых нагрузок справа
   short n_wind_left;             // длина вектора ветровых нагрузок слева
   short n_wind_left_res;             // длина вектора ветровых нагрузок слева
   short n_wind_right;            // длина вектора ветровых нагрузок справа
   short n_wind_right_res;            // длина вектора ветровых нагрузок справа
   double control;              // контрольное число: LOAD_CONTROL
}  LOAD_SET;

typedef struct _par_load  {// Параметры нагрузок, необходимые для получения РСУ

   char name[40];            // наименоваие
   double gamma_f;           // коэффициент надежности
   int type;                 // тип нагрузки
   int group_same;           // № группы однотипных нагрузок
   int group_excl;           // № группы взаимоисключающих нагрузок, либо 0
   int accompany[5];         // номер сопутствующей нагрузки, либо -1
   double koeff_1;           // коэффициент РСУ-1
   double koeff_2;           // коэффициент РСУ-2
   bool flag_crane;        // флаг крановой нагрузки
   bool flag_brake;        // флаг тормозной крановой нагрузки
}  PAR_LOAD;

typedef struct _data_arbit_load  {// Данные о призвольных нагрузках

   char name[40];            // наименоваие
   double gamma_f;           // коэффициент надежности
   short type;               // тип нагрузки
   char index_geom;          // индекс наличия нагрузок на геометрии для сейсмических нагрузок (0 - нагрузки есть, 1 - нагрузок нет)
   char number_comb;         // Номер комбинации нагрузок или -1
   int group_same;           // № группы однотипных нагрузок
   int group_excl;           // № группы взаимоисключающих нагрузок, либо 0
   int accompany[5];         // номер сопутствующей нагрузки, либо -1
   double koeff_1;           // коэффициент РСУ-1
   double koeff_2;           // коэффициент РСУ-2
   int num_plan;             // количество участков
}  LOAD_SET_ARBIT;

typedef struct _data_force {   // Данные о нагрузках(сосредоточенных и распределенных)
   int    option_load;               // вид нагрузки
   short  ref_pos_sectA;             // ссылка на позицию Pos_Sect
   short  ind_sectA;                 // -1: сечение задано позицией; 0: первое сеченик КОЭ; 1: второе сечение КОЭ
   short  ref_pos_sectB;             // ссылка на позицию Pos_Sect
   short  ind_sectB;                 // -1: сечение задано позицией; 0: первое сеченик КОЭ; 1: второе сечение КОЭ
   int    local_load;
   double length;                    // длина участка
   int    flag_dir;                  // флаг способа задания направления
   short  flag_method;               // способ задания нагрузки: methForce || methSNOWREGION || methWINDREGION
   bool   flag_preview;              //
   bool   flag_dummy;               //
   float posA;                      // привязка начала участка
   float posB;                      // привязка конца участка
   float excentr;                   // эксцентриситет для вертикальной нагрузки
   short   i_span;                  // номер пролета для многоконьковой рамы
   short   i_level;                  // номер уровня для многоэтажной рамы
   double Parapet;
   double Karniz;
   double step_rama;                 // шаг рам, при котором были вычислены силы на карнизы и парапеты
   double load_A;                    // значение нагрузки в начале участка
   double load_B;                    // значение нагрузки в конце участка
   double coorA[3];
   double coorB[3];
   double direction[3];              // вектор, вдоль которого действует нагрузка: Px, My, Pz
}  LOAD_FORCE;

typedef struct _data_constraint {   // Данные о закреплениях
   int    ref_pos_sect;             // ссылка на позицию Pos_Sect
   int    local;
   bool   constr[7];                //   закрепления по направлениям
   double coor[3];
}  CONSTRAINT;

typedef struct _constr_rama {    // Данные о постоянных закреплениях
   int    node_left;             // номер левого узла
   char   constr_left[7];        // закрепления левого узла
   int    node_right;            // номер правого узла
   char   constr_right[7];       // закрепления правого узла
   int    node_add[MAX_PLAN_CONSTRAINT];         // дополнительные узлы
   char   constr_add[7];
   int    element_release[MAX_PLAN_CONSTRAINT];    // номер элемента в котором освобождается связь
   int    node_release[MAX_PLAN_CONSTRAINT];     // порядковый номер узла (1 или 2) в котором освобождается связь
   char   release[7];
}  CONSTR_RAMA;

typedef struct _geom_param_sect {   // Геометрические параметры двутаврового сечения
   double Ar;
   double Izz;
   double Iyy;
   double Iyz;
   double Itor;
   double Hsect; // высота сечения (по оси Z)
   double Wsect; // ширина сечения (по оси Y)
   double Zct;   // координта ц.т. сечения относительно внешней грани
   double Yct;   // координта ц.т. сечения относительно боковой грани  Yct = Wsect/2 (сечение предполагается симметричным)
   double Ze;    // координта центра сдвига сечения относительно внешней грани
   double Ye;    // координта центра сдвига сечения относительно боковой грани
   double ky;    // коэффициент сдвиговой жесткости по оси Y
   double kz;    // коэффициент сдвиговой жесткости по оси Z
   double point_stress[4][2]; // координаты точек вычисчления напряжений (для экспорта в NASTRAN)
   double omega[4]; // секториальные координаты в 4-ч точках
   double z_tau[3]; // координаты Z точек вычисчления касательных напряжений (относительно ц.т)
   double Sx[3]; // статичесие моменты в точках вычисления касательных напряжений
   double Sy[3]; // статичесие моменты в точках вычисления касательных напряжений
   double Hp;    // расстояние между ц.т. поясов
   double Zp;    // координта ц.т. сечения относительно ц.т. внешнего пояса
   double Rad;   // радиус скругления полки со стенкой для стандартных профилей
   double alfa;  // Угол между осью Y и главной осью
   double I1;    // Главный момент инерции
   double I2;    // второй главный момент инерции
   double Iw;    // секториальный момент инерции
   double Wx_f;  // Момент сопротивления изгибу сечения, состояшего только из полок
   double Wx_pl; // Пластический момент сопротивления изгибу
   double Wu_max;
   double Wu_min;
   double Wv_max;
   double Wv_min;
   int    index_orient;  // Ориентация сечения 0 - в пл. XZ; 1 - в пл. YZ
}  GEOM_PARAM_SECT;

typedef struct _stress_param_sect {   // параметры напряженного состояния двутаврового сечения
   double sigma_ext;
   double sigma_w_ext; // напряжение в стенке в месте стыка с внешней полкой
   double sigma_int;
   double sigma_w_int; // напряжение в стенке в месте стыка с внутренней полкой
   double sigma_ct;    // напряжение в стенке в центре тяжести сечения
   double Hsect;       // высота сечения
   double Zct;         // координта ц.т. сечения относительно внешней грани
   double z0;         // координата sigma=0, отсчитывается от внешней грани
}  STRESS_PARAM_SECT;

typedef struct _export_scale {   // масштабные параметры экспорта
   double line;   // масштаб линейных размеров
   double sect;   // масштаб сечений
   double ro_g;   // масштаб плотность*ускор_св_пад
   double ro;     // масштаб плотности
   double modules;  // масштаб модулей упругости и сдвига
   double force;    // масштаб сил
}  EXPORT_SCALE;

typedef struct _export_dimension {   // единицы измерения при экспорте в SCAD
   double line;
   double sect;
   double force;
   char   text_line[4];
   char   text_sect[4];
   char   text_force[4];
}  EXPORT_DIMENSION;


typedef struct _base_point {   // базовые точки геометрии рамы
   double kolonna_down_ext_left[2];
   double kolonna_down_int_left[2];
   double kolonna_up_ext_left[2];
   double kolonna_up_ext_right[2];
   double rigel_kol_ext_left[2];
   double rigel_kol_ext_right[2];
   double rigel_konek_ext_left[2];
   double rigel_konek_ext_right[2];
   double intersect_kol_rig_ext_left[2];
   double intersect_kol_rig_int_left[2];
   double intersect_konek_ext[2];
   double intersect_konek_int[2];
   double kolonna_doun_ext_right[2];
   double kolonna_doun_int_right[2];
   double intersect_kol_rig_ext_right[2];
   double intersect_kol_rig_int_right[2];
}  BASE_POINT_RAMA;

typedef struct _destination {   // структура данных о назначении вывода
   bool message;
   bool file;
   bool report;   // вывод в окно для копирования
   AnsiString Name_File;
   FILE *stream;
}  LIST_DEST;

typedef struct _comgen_n {  // общие данные о раме
   char   name_rama[24];
   int    type_rama;
   bool   simm;
   double span;
   double x_konek;
   double z_konek;
   double left_kolonna;  // привязка внешней грани колонны
   double left_z_rigel;  // отметка низа ригеля
   double left_z_kolonna;  // отметка низа колонны
   double left_uklon;
   double right_kolonna;
   double right_z_rigel;
   double right_z_kolonna;
   double right_uklon;
   int n_main_sect;     // число основных сечений
   int n_add_sect;      // число дополнительных сечений
   int n_sect_kolonna_right;
   int n_sect_kolonna_left;
   int n_sect_rigel_right;
   int n_sect_rigel_left;
   int n_edge;           // число ребер жесткости
   int n_mesh_sect;      // число дополнительных линий разбивки
   int n_load_set;       // число вариантов нагружений
   int dummy[9];
}  COM_RAMA_new;  // На самом деле прежний формат

typedef struct _var_analysis {
   int    n_base;     // число базовых вариантов
   char   var_name[SIZE_VAR_NAME];  // имя варианта
   double var_koeff[MAX_VAR_SET];  // коэффициенты при загружениях
}  VAR_ANALYSIS;    // элемент вектора вариантов анализа

typedef struct _param_joint {  // параметры стыков
   char      title_sect[35];  // название сечения
   char      index_cont;     // 0 - сечение внутри цепочки сечений; 1 - первое сечение в цепочке; 2 - последнее сечение
   short     i_span;
   short     simm_joint;  // номер симметричного сечения в списке JOINT_PARAM или -1
   char      sign_sect[8];    // обозначение сечения
   short     type_sect;       // тип сечения  (главное или дополнительное)
   short     group_sect;      // номер группы сечений
   short     index_sect;      // (номер сечения в point_corners?) : ID_sect - порядковый номер в группе сечений
   short     index_sect2;     // имеет смысл для произвольных рам
   short     local_sect;      // расположение сечения
   short     i_level;         // номер уровня
   double    pos_sect;        // позиция сечения
   double    h_sect;          // высота стенки в сечении
   double    angle_sect;      // угол между сечением и вертикальной плоскостью (YZ)
   double    angle_ext_l;     // угол между наружной полкой слева и линией стыка
   double    angle_ext_r;     // угол между наружной полкой справа и линией стыка
   double    angle_int_l;     // угол между внутренней полкой слева и линией стыка
   double    angle_int_r;     // угол между внутренней полкой справа и линией стыка
}  JOINT_PARAM;

typedef struct _send_mark {  // отправочные марки
   char      title[36];  // название марки
   char      sign[8];    // обозначение марки
   short     n_s1;       // номер первого сечения в  Joint_ass
   short     n_s2;
}  SEND_MARK;

/*
int String_double(AnsiString field,AnsiString string, double * number);
int String_double_plus(AnsiString field, AnsiString string, double * number);
int String_double_zero_plus(AnsiString field, AnsiString string, double * number);
int String_double_plus_low(AnsiString field, AnsiString string, double value, double * number);
int String_double_zero_low(AnsiString field, AnsiString string, double value, double * number);
int String_double_zero_plus_low(AnsiString field, AnsiString string, double value, double * number);
int StringInt_plus_low(AnsiString field, AnsiString string, int value, int *number);


void Get_param_sect(SECT_DVUTAVR* section, GEOM_PARAM_SECT *param_sect);
void Get_param_sect_comm(int type,COMMON_SECT* section, GEOM_PARAM_SECT *param_sect);
void Get_param_sect_pop(SECT_DVUTAVR* section, double t_pop, double pos_pop, GEOM_PARAM_SECT *param_sect);
*/
int Set_line(int n_line, double *coor1, double *coor2);
int Set_line_norm(int n_line, int n_base, double *coor);
int Get_coor_intersect(int n_line1, int n_line2, double *coor);
int Get_coor_intersect_norm(int n_line, double *coor0, double *coor);
double Get_intersect(int n_line1, int n_line2, int line_intersect);
int Set_line_paral(int n_line, int n_base, double abs_delta, double *coor);

int Get_Sect_Param(int local_pos, double position, DATA_SECT *sect_at_edge, int *m_base, int *m_add, bool flag_expand);
int Get_Sect_Param_MK(int i_span, int local_pos, double position, DATA_SECT *sect_at_edge, int *m_base, int *m_add, bool flag_expand);
int Get_Sect_Param_MK_level(int i_span, int i_level, int local_sect, double pos_sect, DATA_SECT *sect_at_edge, int *m_sect_base, int *m_sect_add, bool flag_expand);
void  Point_dvutavr(int zero, int zero1, int zero2, SECT_DVUTAVR *sect, float scale, TPoint *vertices);

int EdgeParamToType(EDGE_PARAM *edge);
int Get_m_base(int n1, int n2, int m1, int m2, double *coor_edge, double* pos_edge);
double Calc_h_sect(DATA_SECT *sect, double **point_corners, int n1, int n2);

int Get_base_sect_Down(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_Down_plate(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0, bool flag_expand);
int Get_base_sect_Down_plate0(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0, bool flag_expand);
int Get_base_sect_Up(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_Up_1(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_MD(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_MD_plate(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0, bool flag_expand);
int Get_base_sect_MD_plate0(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0, bool flag_expand);
int Get_base_sect_ManyUp(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_ManyUp_MK(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_Arbit(int *n_point_corners, double** point_corners, DATA_SECT *sect_node,
                   double **coor0, int *num_point_corners, int *i_sect0);
int Get_base_sect_Arbit_Only();                   

void Get_point_corners(int *n_point, double **point_corners);
void Get_point_corners_plate(int *n_point, double **point_corners);
void Get_point_corners_Up(int *n_point, double **point_corners);
void Get_point_corners_Up_plate(int *n_point, double **point_corners);
void Get_point_corners_Up_1(int *n_point, double **point_corners);
void Get_point_corners_Up_1_plate(int *n_point, double **point_corners);
void Get_point_corners_ManyUp(int *n_point, double **point_corners);
void Get_point_corners_ManyUp_plate(int *n_point, double **point_corners);
void Get_point_corners_ManyUp_MK(int *n_point, double **point_corners);
void Get_point_corners_ManyUp_plate_MK(int *n_point, double **point_corners);

void Get_coor_point(int k1, int k2, double ** point_corners, GEOM_PARAM_SECT *param_sect, double **coor,
                    int i_sect, int *num_point_corners);
void Get_point_add(int n1, int n2, double pos_sect, double factor, GEOM_PARAM_SECT *param_sect, double **point_corners, int *n_point);
void Get_point_add_level(int i_level, double pos_sect, double factor, DATA_SECT *sect, double **point_corners,
                   int *n_point);
// Вычислить координаты дополнительных сечений
void Get_point_add_plate(int n1, int n2, double pos_sect, double factor, DATA_SECT *sect, double **point_corners,
                   int *n_point);
// Вычислить координаты сечений внутренних колонн
void Get_point_add_span_plate(int i_span, double pos_sect, DATA_SECT *sect, double **point_corners,
                   int *n_point);
void prinm0(char *str, int m, int n, double **mat);
void prinm_G(char *str, int m, int n, double **mat);   // Печать в формате g
void prinm_i(char *str, int m, int n, int **mat);  // печать матрицы по строкам
void prinm_f(char *str, int m, int n, float **mat);

void Expand(double *coor10, double *coor11, double *coor20, double *coor21, double *coor0);

int Def_closed_point(int local_sect, int n1, int n2, double ** point_corners, int *num_point_corners, DATA_SECT *sect_node );
int Def_closed_point_add(int local_sect, int n1, int n2, double ** point_corners, int *num_point_corners, DATA_SECT *sect_node );
int Def_closed_point_MK(int i_span, int local_sect, int n1, int n2, double ** point_corners, int *num_point_corners, DATA_SECT *sect_node );
int Def_closed_point_add_MK(int i_span, int local_sect, int n1, int n2, double ** point_corners, int *num_point_corners, DATA_SECT *sect_node );

int Alloc_mesh();
int Free_mesh();
int Alloc_elem(int nuz, int nelem);
int Get_point_for_norm_edge(int n0, int n1, int nk, int nr, double pos_sect, double **point_corners, int *n_point_corners,
                             int *n_point_norm_edge);
int Get_coor_pos_min(int n1, int n2, int m1, double **point_corners, double pos_sect, double *coor_edge, double *pos_2, double *pos_min);
int Get_coor_pos(int n1, int n2, double **point_corners, double pos_sect, double *coor_edge, double *pos_2);
int Get_coor_pos_norm(int n1, int n2, double **point_corners, double pos_sect, int k1, int k2,
                      double *coor_edge, double *length, double *pos_2);
double Calc_distance(double **point_corners, int n1, int n2);
int Diag_coincident_edge();
int Diag_coincident_mesh_sect();
int Get_coor_point_pos(double *coor1, double *coor2, double pos_sect, double *coor_point);
int Get_coor_point_pos_un(double *coor1, double *coor2, double pos_point, double *coor_point);

double Get_coor_length(double *coor1, double *coor2);
double Get_coor3_length(double *coor1, double *coor2);
int Get_delta(int n_line, double *coor, double *delta);
int Get_tang(int n_line, double dx, double dy, double *tang);
int Get_angle(int n_line1, int n_line2, double *angle);
int Get_angle_vector(int n_line, double dx, double dy, double *angle);
int Get_angle_coor(double *coor0, double *coor1, double *coor2, double *angle);
int Get_coor_mirror(double *point1, double *point2, double *coor, double *coor_m);

int draw_all();
int draw_mesh();
int draw_geom();
int draw_skelet();

void Set_Frame(bool flag_frame, int X0, int Y0, int X1, int Y1);
int Check_local_sect (int local_sect, double pos_sect);
int Check_local_sect_MK (int i_span, int local_sect, double pos_sect);
int SetNout(bool flag_all, char*elemout, char* nodeout, int*ElemOut, int* Ne);
int Alloc_macro();

void Get_DirNormal(double *coor_face0, double *coor_face1, double factor, double *direction);
void Get_coor_L(double *coor_L, double *coor_face0, double *coor_face1, double pos, double length_face);
int Get_Pos_Sect_local(int i);
double Get_Pos_Sect_pos(int i, double length_face);
// Получить позицию сечения
double Get_Pos_Sect_pos_on_ref(int ref, double lenght_face);
int Get_Pos_Sect_i_sect(int ID_sect, int type_sect); // Получить порядковый номер сечения по номеру в группе и типу сечения
int Get_Pos_Sect_k_sect(int ID_sect, int type_sect); // Получить порядковый номер сечения по номеру в группе и типу сечения
int Get_pos_for_load(LOAD_FORCE *load);
void Get_span_MK_k_j(int ID_sect, int *k, int * i_span);  // Получить k_local и i_span для рамы MK
int Get_Pos_Sect_span(int i);
int Get_Pos_Sect_level(int i);
char* Get_Pos_Sect_title(int i);
char* Get_Pos_Sect_title_type_ID(int type_sect, int ID_sect);
double Get_Pos_Sect_H(int i);
int Get_Pos_Sect_type_on_ref(int ref);


int Get_num_from_title(AnsiString title);
int Reflect_local(int ref_pos);
void GetListMater(int nnel, CONT* cont, DSC_MVC *stif, int **Emat, int *number_mat);
int NumMat(int ind_mat, int ind_weight, int* Emat, int number_mat);

int Get_coor_sect(int type, int i_sect,  double **coor_corners, double **coor_sect, SECT_DVUTAVR *sect_p);
int Get_coor_edge(int i_edge, double **coor_corners, double **coor_sect, SECT_DVUTAVR *sect_p);
int Get_coor_sect_num(int i_sect, double **coor_corners, double **coor_sect, SECT_DVUTAVR *sect_p);
void  Set_coorg0(double t_conv[][4], double **coor, int n_coor, double **coorg);
void Get_coorg0_point(double t_conv[][4], double *coor, double z_mod, double scale, double X_shift, double Y_shift);

void  Set_coorg_all(double t_conv[][4], double **coor, int n_coor, double **coorg);
int GetCoorCorners(double** coor_corners);
int Get_Pos_Sect_list_rigel(int index_left, int *index_Pos_sect, int *n_sect_rigel);
int Search_index(int *index_sect, int i_pos, int n_sect);  // находится в SnowLoad
int ExpandLoadMesh(LOAD_NODAL *load, LOAD_ELEMENTAL *load_el, int *n_load, int *e_load);
int Get_Pos_Sect_list_wind(double level_N0, double level_N1, double level_N2, int *index_Pos_sect, int *n_sect_corners);
double l_app(double *f1, double* f2, double x1, int n);
double l_linap(int npoint, double *y, double step, double xi);

int Get_Sect_wind(int local, double pos, double *pos0);
int Get_Sect_load_MK_level(int i_span, int i_level, int local, double pos);
// Получить номер сечения для определения point_coors
int Get_Sect_load_k_sect(int i_span, int i_level, int local, double pos);
int Get_Sect_load_MK(int i_span, int local, double pos);
int GetCreate_Sect_load_MK_level(int i_span, int i_level, int local, double pos, TObject *Sender);
int GetCreate_Sect_load_MK(int i_span, int local, double pos, TObject *Sender);
int Get_Sect_mesh_MK(int i_span, int local, double pos);
void Print_Pos_Sect();
bool ConfirmDelete(AnsiString name);

double Get_span_z_rigel(int ik);
double Get_span_pos_rigel(int ik);
int FormatInt(double x);
int ChangeActiveLoadSet(int k);
int Get_Pos_Sect_Exp(int local_sect, double *min_pos, double *max_pos);
int CheckCoincidentNodes(int nnuz, int nelem, double **coor, int *index_nuz, int **topo_init, double Del_Merge, int n_base_sect);
int CheckCoincidentRigid(int *index_nuz, int *n_rig_l, int *n_rig_r, int *Rigid_node_left, int *Rigid_node_right);
int CheckCoincidentListNodes(int *index_nuz, int *n_nodes, int *List_nodes);
int CoincidentNodes(int nnuz, double **coor, int *index_nuz, double Del_Merge);
int RenumberTopo(int *index_nuz, int nnel, CONT  * cont, DSC_MVC * elem);
int RenumberNode_Load(int *index_nuz, int n_base_sect, DSC_MVC* node_load);

int getcom();
int getver();
int getdrive();
int getsystem();
void GetStroka(double cod, int shift, char* stroka);
void GetMaska(double cod, int *maska, char* maska_symb);
void GetCod(int *pass, char* stroka);
void GetCodX(int *pass, char* stroka);
void GetStrokaX(double cod, int shift, char* stroka);
void No_Mesh();
void Null_Check();
void  Set_coorg_def(double t_conv[][4], double **coor, double **disp_node, double koeff_disp, int n_coor, double ** coorg);
int CheckCoincidentRigKol(int *index_nuz, int i_ren, int *elem_kol, DSC_MVC * topo_kolonna) ;
double mass_macro(int *point_macro, double **Coor_macro, double t_plast);
double mass_Dvutavr(double coor_macro[4][3], SECT_DVUTAVR *sect, int index_pol);

int Pack_stif(int nnel, CONT* cont, DSC_MVC* stif, int *num_stif_elem, DSC_MVC* pack_stif, int *n_pack_stif);
void FormSignSect();
void GetSign(char* sign);
void ChangeSign(char *sign1, char*sign2);
int SetComboBoxList(TComboBox* ComboBox, char* sign);
int Set_for_Sign(TLabel *Label_I, TComboBox* ComboBox_I, TLabel *Label_O, TComboBox* ComboBox_O,
                 bool flag_external);
int  Get_param_beam(double *gt, GEOM_PARAM_SECT *param_sect);
void SortJoint(int N_joint, JOINT_PARAM *Joint_param);
void SortJoint_Index(int N_joint, JOINT_PARAM *Joint_param, int *index_joint);
void Get_point_corners_MD(int *n_point, double **point_corners);
void Get_point_corners_MD_plate(int *n_point, double **point_corners);
double Get_right_uklon_MD(double **point_corners);
double draft_z_span_kol(int ik);
void Set_index_type_element(int local_cect);
int Get_MaterialProperty(double *Ey, double *Ry,  double *density);
void Set_medium_elem(int *kol_elem_third, int *kol_elem_max, int *kol_elem_up);
int Order_nuz_on_elem(int n_elem, int n_node);
double Fun_fi_e(double lambda_r, double m_ef);
double Fun_alfa(double mx);
double Fun_fi(double lambda_r, double Ey, double Ry);
double Fun_beta(double lambda_y, double lambda_c, double fi_y, double fi_c);
double Fun_psi(double alfa_);
double Fun_eta(double A_, double lambda_, double m_, double *eta_work);
double Fun_eta_tavr(double A_, double lambda_, double m_);
double Fun_koef_stab_edge(double Ey, double Ry, double tau_cr, double mu_, double tw, double a_ots, double W_min, EDGE_PARAM *edge);
double Get_span_pos_konek(int ik);
double Get_uklon_right(double a_right, double *point1, double *point2);
void Get_n1_n2_factor_MK(int i_span, int local_sect, int *n1, int *n2, double *factor);
void SumForces(double massa, double *Sum_Force);
int MassFromConstLoad (double *mass_nodal);
void Get_stress(double Mz, double N,  SECT_DVUTAVR *sect, STRESS_PARAM_SECT *stress_sect,
                double H_sect, double h1_min, double h2_min);
void Get_stress_param(double Mz, double N,  GEOM_PARAM_SECT param_sect, STRESS_PARAM_SECT *stress_sect,
                double H_sect, double h1_min, double h2_min);

void Get_load_cons(int k_cran_load, double H_sect, int index, double *L_cons, double *load_cons, double load_rb);
int Set_kolonn_elem_hing(bool flag_simm_reg, int *kol_elem_up, int *rig_elem_up);
void Get_elem_link(int num_elem, int num_end, int *num_linked);

double Get_for_Level_H1(SECT_DVUTAVR *sect0, int index_mesh);   // Получить высоту сечения с учетом флага сетки
double Get_for_Level_level(double level, SECT_DVUTAVR *sect0, int index_mesh);  // Получить отметку уровня с учетом флага сетки
// Получить список намиенований вариантов загружений
void Get_name_load(AnsiString* name_load);


void Long_form_num_sect(int num_long_sect[MAX_EDGE][2]);
int  Long_check_coin_edge(int k1, int k2, int num_long_sect[MAX_EDGE][2]);
void Long_corner(int l10, int l11, int l20, int l21, int n_long, double **point_scale, double coor_corner_long[2][2]);

int   GetElemFromSect(int n_sect, JOINT_PARAM *JointParam, int n_main_sect, int *n_elem, int *n_nuz, bool flag_RSU);
void  GetListSect(AnsiString Caption_select, int *n_sect, TListBox *ListBox_dummy, JOINT_PARAM* ListSect, int *list_sect_int,
                                             int* n_main_sect, double coor_ext[][3]);
// DECLARE
void Get_point_corners_Arbit(int *n_point, double **point_corners);
void Get_point_add_arbit(int n1, int n2, double pos_sect, double *vector, GEOM_PARAM_SECT *param_sect, double **point_corners,
                   int *n_point);
int cmp_load_force(LOAD_FORCE *elem1, LOAD_FORCE *elem2);

void  Show_sect(int n_sect, int n_main, int *list_index_order, int *index_choice);
void  show_main_sect0(int k);
void  show_add_sect0(int k);
int  CopySectDvutavr(SECT_DVUTAVR *sect1, SECT_DVUTAVR* sect2);


#endif
