;---------------------------------------------------------------------------
; Document name: SC_MNG_STD_SIM.PRO
; Last Modified: Wed Apr 23 13:06:00 1997 (LWANG@sumop1.nascom.nasa.gov)
;---------------------------------------------------------------------------
;+
; PROJECT:
;       SOHO - SUMER
;
; NAME:
;       SC_MNG_STD_SIM
;
; PURPOSE: 
;       Manage study simulation
;
; CATEGORY:
;       SC_SUMER
; 
; SYNTAX: 
;       sc_mng_std_sim, err
;
; INPUTS:
;       None.
;
; OPTIONAL INPUTS: 
;       None.
;
; OUTPUTS:
;       ERR - Error flag. 0: successful, otherwise: failed
;
; OPTIONAL OUTPUTS:
;       None.
;
; KEYWORDS: 
;       None.
;
; COMMON:
;       Too many to mention
;
; RESTRICTIONS: 
;       None.
;
; SIDE EFFECTS:
;       None.
;
; HISTORY:
;       Version 1, May 15, 1995, Emmanuel Petit. Written
;       Version 2, January 24, 1996, Nicolas Morisset, IAS
;          Added current_det parameter for I_SIM7 
;       Version 3, June 12, 1996, Liyun Wang, GSFC/ARC
;          Converted some time and point related parameters into the
;             right units before calling technical simulator
;       Version 4, August 7, 1996, Liyun Wang, NASA/GSFC
;          Started using new technical simulator
;
; CONTACT:
;       Liyun Wang, NASA/GSFC (Liyun.Wang.1@gsfc.nasa.gov)
;-
PRO sc_mng_std_simerr
   COMMON sim_com
@tki_common_share
   IF begin_state EQ 1 THEN tki_tcmd, 'end'
   WIDGET_CONTROL, stds_tit_lbl, $
      SET_VALUE='Technical simulation of current STUDY: Error occurred.'
   WIDGET_CONTROL, stds_vali_bt, SENSITIVE=0
   WIDGET_CONTROL, stds_durlo_bt, SENSITIVE=0
   RETURN
END

PRO sc_mng_stds_event, ev
;---------------------------------------------------------------------------
;  Event handler for study simulation
;---------------------------------------------------------------------------
   COMMON scconst_com
   COMMON screq_com
   COMMON scstd_com
   COMMON scupdstd_com
   COMMON sim_com
   COMMON sclogon_com
   COMMON scmain_com
   COMMON scstdcrit2_com
@tki_common_share

   WIDGET_CONTROL, /HOURGLASS
   WIDGET_CONTROL, ev.id, GET_UVALUE=uval

   CASE uval OF
      'QUIT': BEGIN
         xkill, stds_base
      END

      'LOG': BEGIN
;---------------------------------------------------------------------------
;        Display simu log file
;---------------------------------------------------------------------------
         WIDGET_CONTROL, stds_msg_lbl, $
            SET_VALUE='Technical simulation log file: '+ tki_err_file

         file2widget, tki_err_file, stds_sta_txt
      END

      'RES': BEGIN
;---------------------------------------------------------------------------
;        Display simu out file
;---------------------------------------------------------------------------
         WIDGET_CONTROL, stds_msg_lbl, $
            SET_VALUE='Technical simulation result file: '+ tki_output_file
         file2widget, tki_output_file, stds_sta_txt

      END

      'VALID SIMU': BEGIN
         msg = ['*** Warning ***', $
                'This Operation will freeze your STUDY:'          , $
                'No more change on this STUDY will be avalaible'  , $
                'after validation'                                , $
                ' '                                               , $
                ' '                                               , $
                'Do you confirm operation ?']
         ret = SC_CONFIRM_CRE (700, 280, msg)
         IF (ret EQ 1) THEN BEGIN
;---------------------------------------------------------------------------
;           Update data base
;---------------------------------------------------------------------------
            sc_init_req
            db_request.nb_req = 2
            db_request.req1_str(0) = $
               "SELECT 'T' "                                    + $
               "FROM STUDY "                                    + $
               "FOR UPDATE"
            db_request.req2_str(0) = $
               "UPDATE STUDY "                                  + $
               "SET DURATION="+ STRING (std_dur) + ","          + $
               "ACCUMULATE="  + STRING (std_acc) + ","          + $
               "REV_DATE=SYSDATE, "                             + $
               "REV_SCIENTIST_ID = " + STRING(scientist_id) +","+ $
               "STATUS=1 "                                      + $
               "WHERE ID=" + STRING (std_ident)
            nb_rec = sc_send_req(null, null, null)
            WIDGET_CONTROL, std_tech_done, SET_VALUE='x'

            xkill, stds_base

;---------------------------------------------------------------------------
;           Rebuild std list: remove validated study; Refresh display
;---------------------------------------------------------------------------
            sc_init_req
            db_request.nb_req = 1
            db_request.req1_str(0) = $
               "SELECT "               + $
               "ID,"                   + $
               "USER_ID "              + $
               "FROM STUDY "           + $
               "WHERE SCIENTIST_ID = " + STRING (scientist_id) + " " +$
               "AND STATUS = 0 "       + $
               "ORDER BY USER_ID"
            nb_rec = sc_send_req (rec1, null, null)
            IF (nb_rec(0) GT 0) THEN BEGIN
               WIDGET_CONTROL, std_l_lbl_u, $
                  SET_VALUE=STRTRIM(STRING(nb_rec(0)), 2) + ' Studies'
               WIDGET_CONTROL, std_lst_u, SET_VALUE=rec1(1, *), SET_UVALUE=rec1

               selected_std_idx = 0 ;
               WIDGET_CONTROL, std_lst_u , SET_LIST_SELECT=selected_std_idx
               std_ident = rec1(0, selected_std_idx)
               sc_fmt_std, std_ident, UPDATE
               IF (std_more_flag EQ 1) THEN BEGIN
                  xkill, std_bd_base
                  std_more_flag = 0
                  WIDGET_CONTROL, std_more_bt_u, SENSITIVE=1
                  WIDGET_CONTROL, std_quit_bt_u, SENSITIVE=1

               ENDIF
               std_title_str_n = std_title_str_o
               std_purpo_str_n = std_purpo_str_o
            ENDIF ELSE BEGIN
               sc_err_msg, "WARNING: No more non-validated Study available"
               std_out_flg = 1
               IF (sct_crit_flg  EQ 1) THEN xkill, stdct_base
               IF (std_more_flag EQ 1) THEN xkill, std_bd_base
               xkill, std_base_u
               WIDGET_CONTROL, scmenu_base, SENSITIVE=1 ; Free main menu
            ENDELSE
         ENDIF
      END

      'SHOW': BEGIN
         WIDGET_CONTROL, ev.top, SENSITIVE=0
         sc_dis_file, sim_file_name , 0, 0, 20, 40
         WIDGET_CONTROL, ev.top, SENSITIVE=1
      END

;       'DURATION': BEGIN
;          val = STRING(std_dur, FORMAT='(F9.2)')
;          sc_get_val , 'Study duration in sec', val, 700, 555, 11, err

;          IF (err EQ 0) THEN BEGIN
;             std_dur = FLOAT (val)
;             sc_sec_to_day, std_dur, exec_time

; ;---------------------------------------------------------------------------
; ;           Update info banner
; ;---------------------------------------------------------------------------
;             sc_sec_to_day, FLOAT(std_dur), exec_time
;             accu_byte = STRING(std_acc, FORMAT='(F9.2)')
;             dis_text = ['This Study takes '  + exec_time + ' (' + $
;                         STRING(std_dur, FORMAT='(F9.2)') + ' sec)' , $
;                         'It accumulates '      + accu_byte + ' Kbytes' ]
;             WIDGET_CONTROL, stds_dis_txt, SET_VALUE=dis_text
;          ENDIF
;       END

;       'LOAD': BEGIN
;          val = STRING(std_acc, FORMAT='(F9.2)')
;          sc_get_val , 'Study memory load in Kbytes', val, 700, 555, 11, err

;          IF (err EQ 0) THEN BEGIN
;             std_acc = STRING(FLOAT(val), FORMAT='(F9.2)')
;             accu_byte = STRING(std_acc, FORMAT='(F9.2)')
; ;---------------------------------------------------------------------------
; ;           Update info banner
; ;---------------------------------------------------------------------------
;             sc_sec_to_day, FLOAT(std_dur), exec_time
;             accu_byte = STRING(std_acc, FORMAT='(F9.2)')
;             dis_text = ['This Study takes '  + exec_time + ' (' + $
;                         STRING(std_dur, FORMAT='(F9.2)') + ' sec)' , $
;                         'It accumulates '      + accu_byte + ' Kbytes' ]
;             WIDGET_CONTROL, stds_dis_txt, SET_VALUE=dis_text
;          ENDIF
;       END

      ELSE:

   ENDCASE
END

PRO sc_mng_std_sim, err
;---------------------------------------------------------------------------
;  Main program
;---------------------------------------------------------------------------
   COMMON screq_com
   COMMON scstd_com
   COMMON scupdstd_com
   COMMON help_com
   COMMON scpopseq_com
   COMMON sim_com
   COMMON scconst_com
   COMMON scstd_com
@tki_common_share

   Title = 'SCG: STUDY Simulation'
   err = 0

   duration = 0.0
   load = 0.0
   status = 0
   color_str = ['blue  ', 'violet', 'red   ', 'green ', 'yellow', 'brown ']
   MAX_NB_POINTINGS = 20
   item_index = INTARR(MAX_ITEMS)
   point_zone_flg = 0

   WIDGET_CONTROL, /HOURGLASS

;---------------------------------------------------------------------------
;  Base creation
;---------------------------------------------------------------------------
   stds_base = WIDGET_BASE (TITLE=title, XOFFSET=450, YOFFSET=0, /COLUMN)
   stds_tit_base = WIDGET_BASE (stds_base, /COLUMN, XSIZE=940)
   stds_dis_base = WIDGET_BASE (stds_base, /COLUMN, XSIZE=940)
   stds_plo_base = WIDGET_BASE (stds_base, /COLUMN)
   stds_msg_base = WIDGET_BASE (stds_base, /COLUMN)
   stds_cmd_base = WIDGET_BASE (stds_base, /ROW   )

;---------------------------------------------------------------------------
;  Widgets creation
;---------------------------------------------------------------------------
   stds_tit_lbl = WIDGET_LABEL(stds_tit_base, $
                               VALUE='Technical simulation of current STUDY')
   IF (curr_tm_rate EQ 'H') THEN $
      ret = WIDGET_LABEL(stds_tit_base, $
                         VALUE='*** TELEMETRY RATE: 20 Kbits/s ***') $
   ELSE $
      ret = WIDGET_LABEL(stds_tit_base, $
                         VALUE='*** TELEMETRY RATE: 10 Kbits/s ***')

   stds_dis_txt = WIDGET_TEXT  (stds_dis_base        , $
                                YSIZE=3                )
   stds_plo_drw = WIDGET_DRAW  (stds_plo_base        , $
                                XSIZE=940            , $
                                YSIZE=752          , $
                                Y_SCROLL_SIZE=280    , $
                                X_SCROLL_SIZE=940    , $
                                /SCROLL              , $
                                RETAIN=2)

   dummy = WIDGET_BASE (stds_msg_base, /ROW)
   dummy1 = WIDGET_BASE (dummy, /COLUMN)

   stds_msg_lbl = WIDGET_LABEL (dummy1, VALUE=' ' )

   stds_sta_txt = WIDGET_TEXT  (dummy1              , $
                                YSIZE=26            , $
                                XSIZE=97            , $
                                FONT=Hd_Font        , $
                                /SCROLL)

   dummy2 = WIDGET_BASE (dummy, /COLUMN)
   stds_pta_lbl = WIDGET_LABEL (dummy2 , VALUE='Study area(s)' )

   stds_pta_drw = WIDGET_DRAW  (dummy2              , $
                                XSIZE=300           , $
                                YSIZE=300           , $
                                RETAIN=2)

   stds_pta_lst = WIDGET_LIST  (dummy2              , $
                                XSIZE=23            , $
                                YSIZE=6             , $
                                FONT=Hd_Font        , $
                                UVALUE='PTALST')

   stds_quit_bt = WIDGET_BUTTON(stds_cmd_base, VALUE='QUIT', UVALUE='QUIT')
   stds_vali_bt = WIDGET_BUTTON(stds_cmd_base, VALUE='VALID SIMULATION', $
                                UVALUE='VALID SIMU')

   dummy = WIDGET_BUTTON  (stds_cmd_base, VALUE='Display' , MENU=2)
   ret = WIDGET_BUTTON  (dummy, VALUE='Result File' , UVALUE='RES')
   ret = WIDGET_BUTTON  (dummy, VALUE='Log File'    , UVALUE='LOG')

;   stds_durlo_bt = WIDGET_BUTTON(stds_cmd_base, VALUE='Change result', MENU=2)
;   stds_dur_bt = WIDGET_BUTTON(stds_durlo_bt , VALUE='Duration', $
;                               UVALUE='DURATION')
;   stds_lo_bt = WIDGET_BUTTON(stds_durlo_bt , VALUE='Memory load', $
;                              UVALUE='LOAD')

   WIDGET_CONTROL, stds_base, /REALIZE
   WIDGET_CONTROL, stds_base, SENSITIVE=0

   WIDGET_CONTROL, stds_pta_drw , GET_VALUE=ptar_win

   xmessage, ['Technical Simulation in progress.', '', $
              'Please Wait...'], wbase=wait_base

;---------------------------------------------------------------------------
;  Get list of POP and TC Id
;---------------------------------------------------------------------------
   sc_init_req
   db_request.nb_req = 2
   db_request.req1_str(0) = "SELECT "                + $
      "ITEM_ID,"                                     + $
      "ITEM_TYPE "                                   + $
      "FROM STUDY__ITEM "                            + $
      "WHERE STUDY_ID = " + STRING (std_ident) + " " + $
      "ORDER BY IDX"
   nb_rec = sc_send_req (item_id, tcid, null)
   nb_item = nb_rec(0)

;---------------------------------------------------------------------------
;  Build file names, purge previous ones
;---------------------------------------------------------------------------
   tki_output_file = 'TKI_SIM_OUTPUT.TRC'
   tki_err_file = 'TKI_SIM_OUTPUT.LOG'

   ret = CALL_EXTERNAL("LIBRTL", "LIB$DELETE_FILE", tki_output_file+";*")
   ret = CALL_EXTERNAL("LIBRTL", "LIB$DELETE_FILE", tki_err_file   +";*")

   flag = 0
   dis_flg = 1
   color = 202
   full_arealbl = '*** Study areas list *** '

   nb_pointings = 0
   global_areas = REPLICATE ( {ymin   : 0.0 , $
                               ymax   : 0.0 , $
                               zmin   : 0.0 , $
                               zmax   : 0.0 , $
                               width  : 0.0 , $
                               height : 0.0 , $
                               pz     :0      $
                              }, MAX_NB_POINTINGS)
   
   tki_obj_file = ''
   wid4tki = {sun_win:stds_pta_drw, tech_win:stds_plo_drw, $
              det_win:-1L, spec_win:-1L, text_win:-1L}
   st_tki_init, wid4tki=wid4tki
   
;---------------------------------------------------------------------------
;  Beginning the procedure of calling TKI (and indirectly Tech Simulator) 
;---------------------------------------------------------------------------
   tki_tcmd, 'begin'
   tki_tcmd, '/graph'
   
;---------------------------------------------------------------------------
;  Main loop
;---------------------------------------------------------------------------
   FOR k=0, nb_item-1 DO BEGIN
      IF ( item_id(1, k) EQ 'P') THEN BEGIN ; POP/UDP - POINTING Processing
         IF (FIX(item_id(0, k)) EQ -1) THEN BEGIN
            item_index (nb_pointings) = k+1
            point_zone_flg = 0
            nb_pointings = nb_pointings+1
         ENDIF ELSE BEGIN
            pop_ident = item_id (0, k)

;---------------------------------------------------------------------------
;           Build list of POP param
;---------------------------------------------------------------------------
            sc_init_req
            db_request.nb_req = 1
            db_request.req1_str(0) = $
               "SELECT UNIQUE "                                + $
               "G.G_PARAM_ID,"                                 + $ ; col # 0
               "G.VALUE,"                                      + $ ; col # 1
               "NVL(G.VALUE_FCT,'<null_fct>'),"                + $ ; col # 2
               "G.POP_IDX,"                                    + $ ; col # 3
               "G.SEQ_IDX,"                                    + $ ; col # 4
               "G.I_SEQ_ID,"                                   + $ ; col # 5
               "E.IDX "                                        + $ ; col # 6
               "FROM I_SEQ__G_PARAM G,"                        + $
               "I_SEQ F,"                                      + $
               "I_POP__I_SEQ E "                               + $
               "WHERE G.I_POP_UDP_ID ="+STRING(pop_ident)+ " " + $
               "AND G.I_SEQ_ID = E.I_SEQ_ID "                  + $
               "ORDER BY E.IDX, G.SEQ_IDX"
            
            ret = sc_send_req (popparamlst, null, null)
            nb_par_per_pop = FIX(ret(0))

;*******************************
; Token code interpretation,
; Instrument simulation
; ******************************

;---------------------------------------------------------------------------
;           Get obj file associated to current POP/UDP
;---------------------------------------------------------------------------
            sc_init_req
            db_request.nb_req = 1
            db_request.req1_str(0) = $
               "SELECT "                         + $
               "A.SOURCE_ADD,"                   + $ ; col #0
               "NVL(A.SOURCE_SIM_ADD,'***') "    + $ ; col #1
               "FROM G_POP_UDP A,"               + $
               "I_POP_UDP D "                    + $
               "WHERE D.ID=" + pop_ident + " "   + $
               "AND D.G_POP_UDP_ID = A.ID"
            nb_rec = sc_send_req (tmp, null, null)

            tmp = STRTRIM(tmp, 2)

            IF (tmp(1, 0) EQ '***') THEN pop_obj_file = $
               STRTRIM(STRMID(tmp(0, 0), 0, $
                              STRPOS (tmp(0, 0), ".")), 2) + ".OBJ"  $
            ELSE pop_obj_file = $
               STRTRIM(STRMID(tmp(1, 0), 0, $
                              STRPOS (tmp(1, 0), ".")), 2) + ".OBJ"

;---------------------------------------------------------------------------
;           Feed in new obj file
;---------------------------------------------------------------------------
            tki_obj_file = pop_obj_file
            
            tki_tcmd, 'search_p'
            IF (tki_err NE 0) THEN BEGIN
               sc_mng_std_simerr
               RETURN
            ENDIF

;---------------------------------------------------------------------------
;           Check if curr object is a pop
;---------------------------------------------------------------------------
            sc_init_req
            db_request.nb_req = 1
            db_request.req1_str(0) = "SELECT G_POP_UDP_ID " + $
               "FROM I_POP_UDP "      + $
               "WHERE ID  = " + STRING (pop_ident)
            nb_rec = sc_send_req (gpopid, null, null)
            gpopid = FIX(gpopid(0, 0))

            nbpar = 0
            IF (nb_par_per_pop GT 0) THEN $
               ppidx = WHERE (FIX(popparamlst(3, *)) NE -1, nbpar)

            tki_param_tmp = tki_param_lst
            IF (nbpar GT 0) THEN BEGIN
               FOR i=0, nbpar-1 DO BEGIN
                  tki_param_lst(i).value = popparamlst(1, ppidx(i))
                  tki_param_lst(i).index = popparamlst(3, ppidx(i))
                  tki_param_lst(i).type = $
                     tki_param_tmp(FIX(popparamlst(3, ppidx(i)))-1 ).type

                  IF (gpopid LE 10 ) THEN BEGIN	; POP casee
                     pty = FIX(popparamlst(0, ppidx(i)))
;---------------------------------------------------------------------------
;                    Parameter type={6,4,20,21,26,55} => val = val*4 (time in
;                    0.25 s) 
;---------------------------------------------------------------------------
                     IF (pty EQ 6) OR (pty EQ 14) OR (pty EQ 20) OR $
                        (pty EQ 21) OR (pty EQ 26) OR (pty EQ 55) THEN $
                        tki_param_lst(i).value = $
                        STRING((FLOAT(popparamlst(1, ppidx(i)))*4.0), $
                               FORMAT='(F15.3)')
;---------------------------------------------------------------------------
;                    Parameter type={12,13} => val = val*16 (pointing in
;                    arcsec * 16) 
;---------------------------------------------------------------------------
                     IF (pty EQ 12) OR (pty EQ 13) THEN $
                        tki_param_lst(i).value = $
                        STRTRIM(STRING((FLOAT(popparamlst(1, $
                                                          ppidx(i)))*16.0)), 2)
                  ENDIF
                  IF (tki_param_lst(i).type EQ 'r') THEN $
                     tki_param_lst(i).value = $
                     STRING(FLOAT(tki_param_lst(i).value), FORMAT='(F15.3)')
                  IF (tki_param_lst(i).type EQ 's') THEN $
                     tki_param_lst(i).value = $
                     STRTRIM(STRING(FIX  (tki_param_lst(i).value)), 2)
                  IF (tki_param_lst(i).type EQ 'u') THEN $
                     tki_param_lst(i).value = $
                     STRTRIM(STRING(FIX  (tki_param_lst(i).value)), 2)
               ENDFOR
            ENDIF

            tki_tcmd, 'point', 0, 0
;            IF tki_err NE 0 THEN BEGIN
;               sc_mng_std_simerr
;               RETURN
;            ENDIF

;---------------------------------------------------------------------------
;           Config parameters (if any)
;---------------------------------------------------------------------------
            binflg = 0
            biny = '1'
            binz = '1'
            IF (nb_par_per_pop GT 6) THEN BEGIN
               FOR i=0, 5  DO BEGIN
                  IF (FIX(popparamlst(3, i)) EQ -1) THEN BEGIN
                     CASE FIX (popparamlst(0, i)) OF
                        44: BEGIN
                           binflg = 1
                           biny = popparamlst(1, i)
                        END
                        45: BEGIN
                           binflg = 1
                           binz = popparamlst(1, i)
                        END

                        49: BEGIN
                           tki_tcmd, 'rot_comp', popparamlst(1, i)
                           IF tki_err NE 0 THEN BEGIN
                              sc_mng_std_simerr
                              RETURN
                           ENDIF
                       END
                        51: BEGIN
                           IF (point_zone_flg EQ 0) AND $
                              (nb_pointings GT 0) THEN BEGIN
                              global_areas(nb_pointings-1).pz = $
                                 popparamlst(1, i)
                              point_zone_flg = 1
                           ENDIF
                        END
                        ELSE:
                     ENDCASE
                  ENDIF
               ENDFOR
            ENDIF
            IF (binflg EQ 1) THEN BEGIN
               tki_tcmd, 'binning', biny, binz
            ENDIF
            IF tki_err NE 0 THEN BEGIN
               sc_mng_std_simerr
               RETURN
            ENDIF

            tki_tcmd, '/sim'
            
            dis_flg = 0
            IF tki_err NE 0 THEN BEGIN
               sc_mng_std_simerr
               RETURN
            ENDIF

            nb_area = N_ELEMENTS(tki_area_lst)

;---------------------------------------------------------------------------
;           Compute number of distinct areas
;---------------------------------------------------------------------------
            IF (nb_area GT 1) THEN BEGIN
               tki_area_lst = tki_area_lst(SORT(tki_area_lst(*).y_size))
               IF (N_ELEMENTS(tki_area_lst) GT 1) THEN $
                  tki_area_lst = $
                  tki_area_lst(UNIQ(STRTRIM(STRING(tki_area_lst(*).y_size) , 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).z_size) , 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).y_point), 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).z_point), 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).slitnr) , 2)))
               tki_area_lst = tki_area_lst(SORT(tki_area_lst(*).z_size))
               IF (N_ELEMENTS(tki_area_lst) GT 1) THEN $
                  tki_area_lst = $
                  tki_area_lst(UNIQ(STRTRIM(STRING(tki_area_lst(*).y_size) , 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).z_size) , 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).y_point), 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).z_point), 2) + $
                                    STRTRIM(STRING(tki_area_lst(*).slitnr) , 2)))
               tki_area_lst = tki_area_lst(SORT(tki_area_lst(*).index))

               nb_area = N_ELEMENTS(tki_area_lst)
            ENDIF

            IF (nb_area GE 1) THEN BEGIN

               old_arealbl = full_arealbl
               full_arealbl = STRARR (N_ELEMENTS(old_arealbl) + nb_area)

               arealbl = STRARR (nb_area)

               FOR i=0, nb_area-1 DO BEGIN
                  ya = FLOAT(tki_area_lst(i).y_point) - $
                     FLOAT(tki_area_lst(i).y_size)/2.0
                  yb = FLOAT(tki_area_lst(i).y_point) + $
                     FLOAT(tki_area_lst(i).y_size)/2.0
                  yc = yb
                  yd = ya
                  ye = ya

                  za = FLOAT(tki_area_lst(i).z_point) - $
                     FLOAT(tki_area_lst(i).z_size)/2.0
                  zb = za
                  zc = FLOAT(tki_area_lst(i).z_point) + $
                     FLOAT(tki_area_lst(i).z_size)/2.0
                  zd = zc
                  ze = za

                  arealbl(i) = STRING(tki_area_lst(i).y_size, FORMAT='(I4.4)') + $
                     '" x ' + $
                     STRING(tki_area_lst(i).z_size, FORMAT='(I4.4)') + '"'

                  IF (color LT 206) THEN color = color + 1 $
                  ELSE color = 202

;---------------------------------------------------------------------------
;                 compute extrema
;---------------------------------------------------------------------------
                  IF (nb_pointings GT 0) THEN BEGIN
                     global_areas(nb_pointings-1).ymin = $
                        MIN([ya, yb, yc, yd, ye, global_areas(nb_pointings-1).ymin])
                     global_areas(nb_pointings-1).ymax = $
                        MAX([ya, yb, yc, yd, ye, global_areas(nb_pointings-1).ymax])

                     global_areas(nb_pointings-1).zmin = $
                        MIN([za, zb, zc, zd, ze, global_areas(nb_pointings-1).zmin])
                     global_areas(nb_pointings-1).zmax = $
                        MAX([za, zb, zc, zd, ze, global_areas(nb_pointings-1).zmax])
                  ENDIF
               ENDFOR

               FOR kk=0, N_ELEMENTS(old_arealbl)-1 DO $
                  full_arealbl(kk) = old_arealbl(kk)
               FOR kk=N_ELEMENTS(old_arealbl), N_ELEMENTS(full_arealbl)-1 DO $
                  full_arealbl(kk) = arealbl(kk-N_ELEMENTS(old_arealbl))
               WIDGET_CONTROL, stds_pta_lst, SET_VALUE=full_arealbl
            ENDIF
         ENDELSE
      ENDIF ELSE BEGIN
;---------------------------------------------------------------------------
;        TC Processing
;---------------------------------------------------------------------------

;---------------------------------------------------------------------------
;        Get TC simu function
;---------------------------------------------------------------------------
         tc_ident = item_id(0, k)

;---------------------------------------------------------------------------
;        Build list of TC param
;---------------------------------------------------------------------------
         sc_init_req
         db_request.nb_req = 2
         db_request.req1_str(0) = $
            "SELECT "                       + $
            "G_PARAM_ID,"                   + $ ; col # 0
            "VALUE,"                        + $ ; col # 1
            "IDX "                          + $ ; col # 2
            "FROM I_TC__G_PARAM "           + $
            "WHERE I_TC_ID =" + tc_ident    + $
            " ORDER BY IDX"

         db_request.req2_str(0) = $
            "SELECT "                       + $
            "P.USER_ID "                    + $ ; col # 0
            "FROM G_TC P,"                  + $
            "I_TC Q "                       + $
            "WHERE Q.ID =" + tc_ident + " " + $
            "AND Q.G_TC_ID = P.ID"

         nb_rec = sc_send_req (tcparamlst, tcuid, null)
         nb_tc_param = FIX(nb_rec(0))
         tcuid = STRTRIM (tcuid(0, 0))

;---------------------------------------------------------------------------
;        Convert parameters of types 6,14,20,21,26,55 into 1/4 of
;        seconds and of types 12 and 13 into 1/16 of arcsecs
;---------------------------------------------------------------------------
         FOR i=0, nb_tc_param-1 DO BEGIN
            pty = FIX(tcparamlst(0, i))
            IF (pty EQ 6) OR (pty EQ 14) OR (pty EQ 20) OR (pty EQ 21) OR $
               (pty EQ 26) OR (pty EQ 55) THEN $
               tcparamlst(1, i) = 4.0*tcparamlst(1, i)
            IF (pty EQ 12) OR (pty EQ 13) THEN $
               tcparamlst(1, i) = 16.0*tcparamlst(1, i)
         ENDFOR

         cmd = 'tki_tcmd, tcuid'
         str = ''
         FOR i=0, nb_tc_param-1 DO str = str+', tcparamlst(1,'+$
            STRTRIM(STRING(i), 2)+')'
         cmd = cmd+str
         status = EXECUTE(cmd)
         IF tki_err NE 0 THEN BEGIN
            sc_mng_std_simerr
            RETURN
         ENDIF

      ENDELSE
   ENDFOR

   tki_tcmd, '/stat'
   tki_tcmd, 'end'
   IF tki_err NE 0 THEN BEGIN
      sc_mng_std_simerr
      RETURN
   ENDIF
   
;---------------------------------------------------------------------------
;  Compute Global Areas per POINTING; Update pointings table
;---------------------------------------------------------------------------

    sc_init_req
    db_request.nb_req = 1
    db_request.req1_str(0) = "DELETE FROM POINT_AREA " + $
       "WHERE STUDY_ID = "  + STRING(std_ident)
    ret = sc_send_req (null, null, null)

    FOR i=0, nb_pointings-1 DO BEGIN
       global_areas(i).width = ABS(global_areas(i).ymax-global_areas(i).ymin)
       global_areas(i).height = ABS(global_areas(i).zmax-global_areas(i).zmin)
       
       sc_init_req
       db_request.nb_req = 1
       db_request.req1_str(0) = $
          "INSERT INTO POINT_AREA "                  + $
          "(STUDY_ID, IDX, WIDTH,HEIGHT,ZONE_ID) "   + $
          "VALUES ("                                 + $
          STRTRIM(STRING(std_ident), 2)              + "," + $
          STRTRIM(STRING(item_index (i)), 2)         + "," + $
          STRTRIM(STRING(global_areas(i).width), 2)  + "," + $
          STRTRIM(STRING(global_areas(i).height), 2) + "," + $
          STRTRIM(STRING(global_areas(i).pz), 2)     + ")"
       ret = sc_send_req (null, null, null)
   ENDFOR

   xkill, wait_base

;---------------------------------------------------------------------------
;  Build displayed text
;---------------------------------------------------------------------------
   IF (tki_err EQ 0) THEN BEGIN
      WIDGET_CONTROL, stds_tit_lbl, $
         SET_VALUE='Technical simulation of current STUDY, Status = OK'
   ENDIF ELSE BEGIN
      WIDGET_CONTROL, stds_tit_lbl, $
         SET_VALUE='Technical simulation of current STUDY: Error occurred.'
      WIDGET_CONTROL, stds_vali_bt, SENSITIVE=0
      WIDGET_CONTROL, stds_durlo_bt, SENSITIVE=0
   ENDELSE

   std_dur = tki_out_stc.slot_dur
   std_acc = tki_out_stc.top_mem/1024.0

   sc_sec_to_day, std_dur, exec_time
   accu_byte = STRTRIM(STRING(std_acc), 2)
   last_dur = tki_out_stc.clr_dur
   sc_sec_to_day, last_dur, last_time

   dis_text = ['This STUDY takes '+ exec_time + $
               ' (' + STRTRIM(STRING(std_dur), 2) + ' s)' , $
               'It accumulates '      + accu_byte + ' Kbytes' , $
               'The last '            + last_time + $
               ' are used to clear the memory. ('+ $
               STRTRIM(STRING(last_dur), 2) + ' s)']
   WIDGET_CONTROL, stds_dis_txt, SET_VALUE=dis_text

;---------------------------------------------------------------------------
;  Plot is now done in TKI
;---------------------------------------------------------------------------
;---------------------------------------------------------------------------
;  Build displayed profile
;---------------------------------------------------------------------------
;    WIDGET_CONTROL, stds_plo_drw, GET_VALUE=win_num
;    WSET, win_num
;    !P.MULTI = [0, 1, 8]
;    chsize = 2.5
;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 1)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Telescop Azimuth'                   , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 1)                   , $
;       COLOR=206

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 2)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Telescop Elevation'                 , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 2)                   , $
;       COLOR=205

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 5)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Grating Focus'                      , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 5)                   , $
;       COLOR=207

;    PLOT, is_stat(0:is_curr(1), 9)                , $
;       is_stat(0:is_curr(1), 10)/1024.0           , $
;       XTITLE='Completion time of telemetry (s)'  , $
;       YTITLE='Total RAM load (Kbytes)'           , $
;       TITLE='Memory Load'                        , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(1), 9)               , $
;       is_stat(0:is_curr(1), 10)                  , $
;       COLOR=204

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 3)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Slit'                               , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 3)                   , $
;       COLOR=200

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 4)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Slit Focus'                         , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 4)                   , $
;       COLOR=203

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 6)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Scan Miror'                         , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 6)                   , $
;       COLOR=202

;    PLOT, is_stat(0:is_curr(0), 8)                , $
;       is_stat(0:is_curr(0), 0)                   , $
;       XTITLE='Completion time of mechanism (s)'  , $
;       YTITLE='State of mechanism'                , $
;       TITLE='Door'                               , $
;       CHARSIZE=chsize                            , $
;       XTICKLEN=0.11                              , $
;       XMINOR=20                                  , $
;       /NODATA
;    OPLOT, is_stat(0:is_curr(0), 8)               , $
;       is_stat(0:is_curr(0), 0)                   , $
;       COLOR=201

;    !P.MULTI = [0, 1, 1]

   WIDGET_CONTROL, stds_msg_lbl, SET_VALUE=' '
   WIDGET_CONTROL, stds_base, SENSITIVE=1

;---------------------------------------------------------------------------
;  Display simu log file
;---------------------------------------------------------------------------
   WIDGET_CONTROL, stds_msg_lbl, $
      SET_VALUE='Technical simulation log file: '+ tki_err_file
   
   file2widget, tki_err_file, stds_sta_txt

   XMANAGER, 'sc_mng_stds', stds_base, /MODAL

END

;---------------------------------------------------------------------------
;  End of 'SC_MNG_STD_SIM.PRO'
;---------------------------------------------------------------------------
