{ *************************************************************************** }
MODULE mod_init_sptrg ;
{  Created  29-APR-1989   MICHIGAN STATE UNIVERSITY, TRIGGER CONTROL SOFTWARE }
{ *************************************************************************** }
INCLUDE
  mod_common_global_flags,
  mod_def_hardware_tables,
  mod_def_physics_tables,
  mod_handle_tracing,
  mod_io_allocation_handling,
  mod_handle_sptrg,
  mod_init_geosec,
  mod_handle_jet_list,
  mod_common_hard_io ;                {from the TRICS hardware IO library     }
{ *************************************************************************** }
EXPORT
  init_all_sptrg,    {PROCEDURE initialize all sptrg                          }
  restore_all_sptrg, {PROCEDURE restore programming of all sptrg from database}
  initialize_sptrg,  {PROCEDURE initialize one specific trigger               }
  reset_sptrg_scalers, {PROCEDURE reset scalers of one specific trigger       }
  check_alloc_sptrg_coor ;{PROCEDURE check/allocate specific triggre to COOR  }
{ *************************************************************************** }
IMPORT

  status_type,                        {from module MOD_COMMON_GLOBAL_FLAGS    }
  ok,{already_done,}io_failure,       {from module MOD_COMMON_GLOBAL_FLAGS    }

 {state_type,} ON, OFF,               {from module MOD_HANDLE_TRACING         }
  trace_info,{trace_warn,}trace_error,{from module MOD_HANDLE_TRACING         }
  inline_tracing,                     {from module MOD_HANDLE_TRACING         }
  handle_trc_inf,                     {from module MOD_HANDLE_TRACING         }
  handle_trc_err,                     {from module MOD_HANDLE_TRACING         }
  handle_trc_sys,                     {from module MOD_HANDLE_TRACING         }
  modify_trace_inf,                   {from module MOD_HANDLE_TRACING         }
  modify_trace_wrn,                   {from module MOD_HANDLE_TRACING         }
  modify_trace_err,                   {from module MOD_HANDLE_TRACING         }
  modify_io_tracing,                  {from module MOD_HANDLE_TRACING         }
  modify_db_tracing,                  {from module MOD_HANDLE_TRACING         }
  save_tracing_status,                {from module MOD_HANDLE_TRACING         }
  restore_tracing_status,             {from module MOD_HANDLE_TRACING         }

  allocate_trigger,                   {from module MOD_IO_ALLOCATION_HADLLING }
  deallocate_trigger,                 {from module MOD_IO_ALLOCATION_HADLLING }

  threshold_reference_set_number,     {from module MOD_DEF_HARDWARE_TABLES    }
  ref_0, ref_3, ref_7,                {from module MOD_DEF_HARDWARE_TABLES    }
  threshold_comparison_type,          {from module MOD_DEF_HARDWARE_TABLES    }
  EMEt_cmp, TOTEt_cmp, LgTile_cmp,    {from module MOD_DEF_HARDWARE_TABLES    }

  trc_err_init_odb_FW,                {from module MOD_DEF_PHYSICS_TABLES     }
 {possible_allocation,}all_none, all_coor,{all_phat,  all_redundancy,}
                                      {from module MOD_DEF_PHYSICS_TABLES     }
  sptrg,                              {from module MOD_DEF_PHYSICS_TABLES     }
  targ_acqbandw,                      {from module MOD_DEF_PHYSICS_TABLES     }
  jet_list_progr,                     {from module MOD_DEF_PHYSICS_TABLES     }

  enable_global,                      {from module MOD_HANDLE_SPTRG           }
  prog_prescaler,                     {from module MOD_HANDLE_SPTRG           }
  enable_obeybz,                      {from module MOD_HANDLE_SPTRG           }
  enable_obeyl2,                      {from module MOD_HANDLE_SPTRG           }
  enable_obeybeam,                    {from module MOD_HANDLE_SPTRG           }
  enable_autodis,                     {from module MOD_HANDLE_SPTRG           }
  prog_aoterm,                        {from module MOD_HANDLE_SPTRG           }
  prog_startdgt,                      {from module MOD_HANDLE_SPTRG           }
  prog_watchbusy,                     {from module MOD_HANDLE_SPTRG           }
  reset_sptrg_aofired_scaler,         {from module MOD_HANDLE_SPTRG           }
  reset_sptrg_fired_scaler,           {from module MOD_HANDLE_SPTRG           }
  reset_sptrg_exposed_scaler,         {from module MOD_HANDLE_SPTRG           }
  reset_sptrg_veto_scalers,           {from module MOD_HANDLE_SPTRG           }
  reset_sptrg_l15_scalers,            {from module MOD_HANDLE_SPTRG           }
  level15_type,                       {from module MOD_HANDLE_SPTRG           }
  prog_l15confirm,                    {from module MOD_HANDLE_SPTRG           }

  prog_jet_list,                      {from module MOD_HANDLE_JET_LIST        }

  cbus_param_list ;                   {from module MOD_COMMON_HARD_IO         }
{ *************************************************************************** }
{ *************************************************************************** }

  %INCLUDE 'SITE_DEPENDENT.CST/LIST'

TYPE

  bit  = [BIT(1)] 0..1     ;
  byte = [BYTE]   0..255   ;

  boolean_by_bit = [BYTE]
  PACKED RECORD
    bit  : [POS(0)] bit ;
    rest : [POS(1)] 0..127 ;
  END ;

VAR

  tag        : VARYING_STRING(8) := 'INI/ODB%' ;

{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE init_all_sptrg ( tagext : VARYING_STRING(16) := 'ini_spt%' ;
                           inipar :^cbus_param_list := NIL ; 
                       VAR status : [OPTIONAL] status_type ) ;

VAR 

  sptrgnum       : INTEGER ;
  ini_status     : status_type ;
  local_io_param : BOOLEAN := TRUE ;
  fail_count     : INTEGER ;

BEGIN

  IF PRESENT(status) THEN status := ok ;

  handle_trc_sys ( TAG := tag + tagext , 
               MESSAGE := ' Initializing all Specific Triggers ' ) ;

  save_tracing_status ;

  modify_trace_inf ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  modify_trace_wrn ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  IF ( trace_error.logfile = ON ) 
  THEN modify_trace_err ( CONSOLE := OFF, 
                          LOGFILE := trc_err_init_odb_fw, REPORT := FALSE ) 
  ELSE modify_trace_err ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  modify_db_tracing (  STATE :=  ON, REPORT := FALSE ) ;
  modify_io_tracing (  STATE := OFF, REPORT := FALSE ) ;

{ *** allocate memory for the register initialization parameter list      *** }
  IF ( inipar = NIL ) 
  THEN BEGIN 
    local_io_param := TRUE ;
    NEW ( inipar ) ;
    deallocate_trigger ( TAGEXT := tagext, REPORT := FALSE  ) ;
    allocate_trigger ( TAGEXT := tagext, CALLER_ID := inipar, REPORT := FALSE  );
  END 
  ELSE local_io_param := FALSE ;

  fail_count := 0 ;

  targ_acqbandw := default_targ_acqbandw ; {target use of acq bandwidth } 

  FOR  sptrgnum := firstsptrg TO lastsptrg 
  DO BEGIN

    initialize_sptrg ( SPTRGNUM := sptrgnum, 
                         TAGEXT := tagext,
                CHECK_DBSCALERS := TRUE,
                         INIPAR := inipar,
                         STATUS := ini_status ) ;

    IF ( ini_status = io_failure ) 
    THEN BEGIN

      fail_count := fail_count + 1 ;
      
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #' 
                                 + CONVERT(STRING,sptrgnum) ) ;
    END ;
  END ;

{ *** release the memory from the register initialization io parameters   *** }
  IF ( local_io_param = TRUE )
  THEN BEGIN 
    DISPOSE ( inipar ) ;
    deallocate_trigger ( TAGEXT := tagext, REPORT := FALSE  ) ;
  END ;

  restore_tracing_status ( REPORT := FALSE ) ;

  IF ( fail_count  <> 0 )
  THEN BEGIN
    handle_trc_err ( TAG := tag + tagext,
                 MESSAGE := ' Spec Trig Initialization Failure Count Is '
                          + CONVERT(STRING,fail_count)
                          + ', Check Log File'  ) ;
    IF PRESENT(status) THEN status := io_failure ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE initialize_sptrg ( tagext : VARYING_STRING(16) := '' ;
                           sptrgnum : INTEGER ;
                    check_dbscalers : BOOLEAN := FALSE ;
                             inipar :^cbus_param_list := NIL ;
                         VAR status :[OPTIONAL] status_type ) ;

VAR

  aotermnum      : INTEGER ;
  geosecnum      : INTEGER ;
  l15termnum     : INTEGER ;
  ini_status     : status_type ;
  local_io_param : BOOLEAN := TRUE ;
  refsettype     : threshold_comparison_type ;
  refsetnum      : threshold_reference_set_number ;

BEGIN

  IF PRESENT(status) THEN status := ok ;

{ *** allocate memory for the register initialization parameter list      *** }
  IF ( inipar = NIL ) 
  THEN NEW ( inipar ) 
  ELSE local_io_param := FALSE ;

  IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := tag + tagext,
                    MESSAGE := ' Initializing Specific Trigger # ' 
                             + CONVERT(STRING,sptrgnum) ) ;

  sptrg[sptrgnum]^.read_time := 100 ;{default 100ms readout time}

  enable_global ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  ENABLE := FALSE,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' to be Globally Disabled' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  prog_prescaler ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                 PRESCALE := FALSE,
                    RATIO := 1,
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Not to be Prescaled ' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;
 
  enable_obeybz ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  OBEYBZ := TRUE,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' to Obey Front-End Busy Decision ' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  enable_obeyl2 ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  OBEYL2 := FALSE,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' to Ignore Level 2 Disable Signal ' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  enable_obeybeam ( TAGEXT := tagext, 
                  SPTRGNUM := sptrgnum, 
                  OBEYBEAM := FALSE,
                     IOPAR := inipar,
                    STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' to Ignore Beam Quality Veto ' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  enable_autodis ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                  AUTODIS := FALSE,
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Not to be Autodisabled ' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  FOR aotermnum := firstaoterm TO lastaoterm 
  DO BEGIN
    prog_aoterm ( TAGEXT := tagext,
                SPTRGNUM := sptrgnum,
               AOTERMNUM := aotermnum,
                EXCLUDED := TRUE,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Andor Input Term #'
                                 + CONVERT(STRING,aotermnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

  prog_aoterm ( TAGEXT := tagext,
              SPTRGNUM := sptrgnum,
             AOTERMNUM := aoterm_high,
              POLARITY := FALSE,
                 IOPAR := inipar,
                STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Aoterm Fixed High #'
                               + CONVERT(STRING,aoterm_high) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  FOR geosecnum := firstgeosec TO lastgeosec 
  DO BEGIN
    prog_startdgt ( TAGEXT := tagext,
                  SPTRGNUM := sptrgnum,
                 GEOSECNUM := geosecnum,
                  DIGITIZE := FALSE,
                     IOPAR := inipar,
                    STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum)
                                 + ' Digitizing of Geo Sec#'
                                 + CONVERT(STRING,geosecnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

    prog_watchbusy ( TAGEXT := tagext,
                   SPTRGNUM := sptrgnum,
                  GEOSECNUM := geosecnum,
                    WATCHBZ := FALSE,
                      IOPAR := inipar,
                     STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' to Ignore Busy from Geo Sec#'
                                 + CONVERT(STRING,geosecnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  END ;

  IF ( ( sptrgnum >= firstL15sptrg ) 
   AND ( sptrgnum <= lastL15sptrg  ) ) 
  THEN BEGIN 

    level15_type ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                 LEVEL_15 := FALSE,
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' to be Pure Level 1' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
   
    FOR l15termnum := firstl15term TO lastl15term 
    DO BEGIN
      prog_l15confirm ( TAGEXT := tagext,
                      SPTRGNUM := sptrgnum,
                    L15TERMNUM := l15termnum,
                       REQUIRE := FALSE,
                         IOPAR := inipar,
                        STATUS := ini_status ) ;
      IF ( ini_status = io_failure ) 
      THEN BEGIN
        IF ( inline_tracing(trace_error) <> 0 )
        THEN handle_trc_err ( TAG := tag + tagext,
                          MESSAGE := ' Failure Initializing Spec Trig #'
                                   + CONVERT(STRING,sptrgnum)
                                   + ' Requiring of L1.5 Term #'
                                   + CONVERT(STRING,l15termnum) ) ;
        IF PRESENT(status) THEN status := ini_status ;
      END ;
  
    END ;

  END ;

  reset_sptrg_scalers ( SPTRGNUM := sptrgnum, 
                          TAGEXT := tagext,
                 CHECK_DBSCALERS := TRUE,
                           IOPAR := inipar,
                          STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Initializing Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Reset of Scalers' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  FOR refsettype := EMEt_cmp TO TOTEt_cmp
  DO FOR refsetnum := ref_0 TO ref_3 
  DO BEGIN
    prog_jet_list ( TAGEXT := tagext, 
               REFSET_TYPE := refsettype,
                REFSET_NUM := refsetnum,
                  SPTRGNUM := sptrgnum, 
               IN_JET_LIST := FALSE,
                     IOPAR := inipar, 
                    STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Not to participate in Jet List for '
                                 + CONVERT(STRING,refsettype)
                                 + ', ' + CONVERT(STRING,refsetnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

  FOR refsetnum := ref_0 TO ref_7
  DO BEGIN
    prog_jet_list ( TAGEXT := tagext, 
               REFSET_TYPE := LgTile_cmp,
                REFSET_NUM := refsetnum,
                  SPTRGNUM := sptrgnum, 
               IN_JET_LIST := FALSE,
                     IOPAR := inipar, 
                    STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Not to participate in Large Tile List for '
                                 + CONVERT(STRING,refsetnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

{ *** release the memory from the register initialization io parameters   *** }
  IF ( local_io_param = TRUE )
  THEN BEGIN 
    DISPOSE ( inipar ) ;
  END ;

  sptrg[sptrgnum]^.status.initialized := TRUE ;
  sptrg[sptrgnum]^.allocated          := ALL_NONE ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE restore_all_sptrg ( tagext : VARYING_STRING(16) := 'res_spt%' ;
                              inipar :^cbus_param_list := NIL ; 
                          VAR status : [OPTIONAL] status_type ) ;

VAR 

  sptrgnum       : INTEGER ;
  ini_status     : status_type ;
  local_io_param : BOOLEAN := TRUE ;
  fail_count     : INTEGER ;

BEGIN

  IF PRESENT(status) THEN status := ok ;

  handle_trc_sys ( TAG := tag + tagext , 
               MESSAGE := ' Restoring all Specific Triggers ' ) ;

  save_tracing_status ;

  modify_trace_inf ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  modify_trace_wrn ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  IF ( trace_error.logfile = ON ) 
  THEN modify_trace_err ( CONSOLE := OFF, 
                          LOGFILE := trc_err_init_odb_fw, REPORT := FALSE ) 
  ELSE modify_trace_err ( CONSOLE := OFF, LOGFILE := OFF, REPORT := FALSE ) ;
  modify_db_tracing (  STATE :=  ON, REPORT := FALSE ) ;
  modify_io_tracing (  STATE := OFF, REPORT := FALSE ) ;

{ *** allocate memory for the register initialization parameter list      *** }
  IF ( inipar = NIL ) 
  THEN BEGIN 
    local_io_param := TRUE ;
    NEW ( inipar ) ;
    deallocate_trigger ( TAGEXT := tagext, REPORT := FALSE  ) ;
    allocate_trigger ( TAGEXT := tagext, CALLER_ID := inipar, REPORT := FALSE  );
  END 
  ELSE local_io_param := FALSE ;

  fail_count := 0 ;

  FOR  sptrgnum := firstsptrg TO lastsptrg 
  DO BEGIN

    restore_sptrg ( SPTRGNUM := sptrgnum, 
                      TAGEXT := tagext,
             CHECK_DBSCALERS := TRUE,
                      INIPAR := inipar,
                      STATUS := ini_status ) ;

    IF ( ini_status = io_failure ) 
    THEN BEGIN
        
      fail_count := fail_count + 1 ;
      
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #' 
                                 + CONVERT(STRING,sptrgnum) ) ;
    END ;
  END ;

{ *** release the memory from the register initialization io parameters   *** }
  IF ( local_io_param = TRUE )
  THEN BEGIN 
    DISPOSE ( inipar ) ;
    deallocate_trigger ( TAGEXT := tagext, REPORT := FALSE  ) ;
  END ;

  restore_tracing_status ( REPORT := FALSE ) ;

  IF ( fail_count  <> 0 )
  THEN BEGIN
    handle_trc_err ( TAG := tag + tagext,
                 MESSAGE := ' Spec Trig Restoration Failure Count Is '
                          + CONVERT(STRING,fail_count)
                          + ', Check Log File'  ) ;
    IF PRESENT(status) THEN status := io_failure ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE restore_sptrg ( tagext : VARYING_STRING(16) := '' ;
                        sptrgnum : INTEGER ;
                 check_dbscalers : BOOLEAN := FALSE ;
                          inipar :^cbus_param_list := NIL ;
                      VAR status :[OPTIONAL] status_type ) ;

VAR

  aotermnum         : INTEGER ;
  geosecnum         : INTEGER ;
  l15termnum        : INTEGER ;
  refsettype        : threshold_comparison_type ;
  refsetnum         : threshold_reference_set_number ;
  ini_status        : status_type ;
  local_io_param    : BOOLEAN := TRUE ;
  restore_enable           : boolean_by_bit ;
  restore_prescaler        : boolean_by_bit ;
  restore_fendbz           : boolean_by_bit ;
  restore_level2           : boolean_by_bit ;
  restore_beam             : boolean_by_bit ;
  restore_autodis          : boolean_by_bit ;
  restore_aoterm_exclusion : boolean_by_bit ;
  restore_aoterm_polarity  : boolean_by_bit ;
  restore_geosec_digitize  : boolean_by_bit ;
  restore_geosec_watchbusy : boolean_by_bit ;
  restore_l15term_require  : boolean_by_bit ; 
  restore_jet_list_prog    : boolean_by_bit ; {zeroed below}

BEGIN

  IF PRESENT(status) THEN status := ok ;

{ *** allocate memory for the register initialization parameter list      *** }
  IF ( inipar = NIL ) 
  THEN NEW ( inipar ) 
  ELSE local_io_param := FALSE ;

  IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := tag + tagext,
                    MESSAGE := ' Restoring Specific Trigger # ' 
                             + CONVERT(STRING,sptrgnum) ) ;

  restore_enable           := ZERO ;
  restore_prescaler        := ZERO ;
  restore_fendbz           := ZERO ;
  restore_level2           := ZERO ;
  restore_beam             := ZERO ;
  restore_autodis          := ZERO ;
  restore_aoterm_exclusion := ZERO ;
  restore_aoterm_polarity  := ZERO ;
  restore_geosec_digitize  := ZERO ;
  restore_geosec_watchbusy := ZERO ;
  restore_l15term_require  := ZERO ;
  restore_jet_list_prog    := ZERO ;

  restore_enable.bit := 1 - sptrg[sptrgnum]^.enable.globaldis::bit ; 
  {invert state because enable = disobey global disable}
  {this dummy transfer solves alignment, size and typecasting problem}
  enable_global ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  ENABLE := restore_enable::BOOLEAN,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Globally Disabled = ' 
                         + CONVERT(STRING,sptrg[sptrgnum]^.enable.globaldis) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  restore_prescaler.bit := sptrg[sptrgnum]^.enable.prsc::bit ;
  prog_prescaler ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                 PRESCALE := restore_prescaler::BOOLEAN,
                    RATIO := sptrg[sptrgnum]^.prscratio,
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Prescaled by '
                               + CONVERT(STRING,sptrg[sptrgnum]^.prscratio)
                      + ' = ' + CONVERT(STRING,sptrg[sptrgnum]^.enable.prsc) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;
 
  restore_fendbz.bit := sptrg[sptrgnum]^.enable.fendbz::bit ;
  enable_obeybz ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  OBEYBZ := restore_fendbz::BOOLEAN,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Front-End Busy Decision = ' 
                         + CONVERT(STRING,sptrg[sptrgnum]^.enable.fendbz) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  restore_level2.bit := sptrg[sptrgnum]^.enable.level2::bit ;
  enable_obeyl2 ( TAGEXT := tagext, 
                SPTRGNUM := sptrgnum, 
                  OBEYL2 := restore_level2::BOOLEAN,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Level 2 = ' 
                           + CONVERT(STRING,sptrg[sptrgnum]^.enable.level2) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  restore_beam.bit := sptrg[sptrgnum]^.enable.beam::bit ;
  enable_obeybeam ( TAGEXT := tagext, 
                  SPTRGNUM := sptrgnum, 
                  OBEYBEAM := restore_beam::BOOLEAN,
                     IOPAR := inipar,
                    STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Beam Veto = ' 
                           + CONVERT(STRING,sptrg[sptrgnum]^.enable.beam) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  restore_autodis.bit := sptrg[sptrgnum]^.enable.autodis::bit ;
  enable_autodis ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                  AUTODIS := restore_autodis::BOOLEAN, 
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Autodisable = ' 
                          + CONVERT(STRING,sptrg[sptrgnum]^.enable.autodis) ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  FOR aotermnum := firstaoterm TO lastaoterm 
  DO BEGIN
    restore_aoterm_exclusion.bit :=
                  sptrg[sptrgnum]^.aoterm[aotermnum].excluded ;    
    restore_aoterm_polarity.bit  :=
                  sptrg[sptrgnum]^.aoterm[aotermnum].polarity ;
    prog_aoterm ( TAGEXT := tagext,
                SPTRGNUM :=  sptrgnum, 
               AOTERMNUM := aotermnum,
                EXCLUDED := restore_aoterm_exclusion::BOOLEAN,
                POLARITY := restore_aoterm_polarity::BOOLEAN,
                   IOPAR := inipar,
                  STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Andor Term #'
                                 + CONVERT(STRING,aotermnum) 
             + ' excl = ' + CONVERT(STRING,restore_aoterm_exclusion::BOOLEAN) 
             + ', pol = ' + CONVERT(STRING,restore_aoterm_polarity::BOOLEAN) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

  FOR geosecnum := firstgeosec TO lastgeosec 
  DO BEGIN
    restore_geosec_digitize.bit := sptrg[sptrgnum]^.geosec[geosecnum].digitize ;
    prog_startdgt ( TAGEXT := tagext,
                  SPTRGNUM := sptrgnum,
                 GEOSECNUM := geosecnum,
                  DIGITIZE := restore_geosec_digitize::BOOLEAN, 
                     IOPAR := inipar,
                    STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #'
                                 + CONVERT(STRING,sptrgnum)
                                 + ' Digitizing of Geo Sec#'
                                 + CONVERT(STRING,geosecnum) 
                 + ' = ' + CONVERT(STRING,restore_geosec_digitize::BOOLEAN) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

    restore_geosec_watchbusy.bit := sptrg[sptrgnum]^.geosec[geosecnum].watchbz ;
    prog_watchbusy ( TAGEXT := tagext,
                   SPTRGNUM := sptrgnum,
                  GEOSECNUM := geosecnum,
                    WATCHBZ := restore_geosec_watchbusy::BOOLEAN, 
                     IOPAR := inipar,
                     STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Watch Busy from Geo Sec#'
                                 + CONVERT(STRING,geosecnum) 
                 + ' = ' + CONVERT(STRING,restore_geosec_watchbusy::BOOLEAN) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  END ;

  IF ( ( sptrgnum >= firstL15sptrg ) 
   AND ( sptrgnum <= lastL15sptrg  ) ) 
  THEN BEGIN 

    level15_type ( TAGEXT := tagext, 
                 SPTRGNUM := sptrgnum, 
                 LEVEL_15 := sptrg[sptrgnum]^.level_15, 
                    IOPAR := inipar,
                   STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Level 1/1.5 Type' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
   
    FOR l15termnum := firstl15term TO lastl15term 
    DO BEGIN
      restore_l15term_require.bit := sptrg[sptrgnum]^.l15term[l15termnum] ;
      prog_l15confirm ( TAGEXT := tagext,
                      SPTRGNUM := sptrgnum,
                    L15TERMNUM := l15termnum,
                       REQUIRE := restore_l15term_require::BOOLEAN,
                         IOPAR := inipar,
                        STATUS := ini_status ) ;
      IF ( ini_status = io_failure ) 
      THEN BEGIN
        IF ( inline_tracing(trace_error) <> 0 )
        THEN handle_trc_err ( TAG := tag + tagext,
                          MESSAGE := ' Failure Restoring Spec Trig #'
                                   + CONVERT(STRING,sptrgnum)
                                   + ' Requiring of L1.5 Term #'
                                   + CONVERT(STRING,l15termnum) ) ;
        IF PRESENT(status) THEN status := ini_status ;
      END ;
  
    END ;

  END ;

  reset_sptrg_scalers ( SPTRGNUM := sptrgnum, 
                          TAGEXT := tagext,
                 CHECK_DBSCALERS := TRUE,
                           IOPAR := inipar,
                          STATUS := ini_status ) ;
  IF ( ini_status = io_failure ) 
  THEN BEGIN
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := tag + tagext,
                      MESSAGE := ' Failure Restoring Spec Trig #'
                               + CONVERT(STRING,sptrgnum) 
                               + ' Reset of Scalers' ) ;
    IF PRESENT(status) THEN status := ini_status ;
  END ;

  FOR refsettype := EMEt_cmp TO TOTEt_cmp
  DO FOR refsetnum := ref_0 TO ref_3 
  DO BEGIN
    restore_jet_list_prog.bit :=
      jet_list_progr[refsettype,refsetnum].bit[sptrgnum]::bit ;
    prog_jet_list ( TAGEXT := tagext, 
               REFSET_TYPE := refsettype,
                REFSET_NUM := refsetnum,
                  SPTRGNUM := sptrgnum, 
               IN_JET_LIST := restore_jet_list_prog::BOOLEAN,
                     IOPAR := inipar, 
                    STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Restoring Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' to participate in Jet List for '
                                 + CONVERT(STRING,refsettype)
                                 + ', ' + CONVERT(STRING,refsetnum) ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

{ *** release the memory from the register initialization io parameters   *** }
  IF ( local_io_param = TRUE )
  THEN BEGIN 
    DISPOSE ( inipar ) ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE reset_sptrg_scalers ( tagext : VARYING_STRING(16) := '' ;
                              sptrgnum : INTEGER ;
                       check_dbscalers : BOOLEAN := FALSE ;
                                 iopar :^cbus_param_list ;
                            VAR status :[OPTIONAL] status_type ) ;

VAR

  ini_status : status_type ;

BEGIN

  IF PRESENT(status) THEN status := ok ;

  IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := tag + tagext,
                    MESSAGE := ' Resetting Scalers of Specific Trigger # ' 
                             + CONVERT(STRING,sptrgnum) ) ;

  reset_sptrg_aofired_scaler ( TAGEXT := tagext,
                             SPTRGNUM := sptrgnum,
                                IOPAR := iopar, 
                               STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Spec Trig Andor Fired Scaler ' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  reset_sptrg_fired_scaler ( TAGEXT := tagext,
                           SPTRGNUM := sptrgnum,
                              IOPAR := iopar, 
                        CHECK_RESET := check_dbscalers,
                             STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Spec Trig Fired Scaler ' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  reset_sptrg_exposed_scaler ( TAGEXT := tagext,
                             SPTRGNUM := sptrgnum,
                                IOPAR := iopar, 
                          CHECK_RESET := check_dbscalers,
                               STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Spec Trig Exposition Scaler ' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  reset_sptrg_veto_scalers ( TAGEXT := tagext,
                           SPTRGNUM := sptrgnum,
                              IOPAR := iopar, 
                             STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Veto Scalers ' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;

  
  IF ( ( sptrgnum >= firstL15sptrg ) 
   AND ( sptrgnum <= lastL15sptrg  ) ) 
  THEN BEGIN
    reset_sptrg_l15_scalers ( TAGEXT := tagext,
                            SPTRGNUM := sptrgnum,
                               IOPAR := iopar, 
                              STATUS := ini_status ) ;
    IF ( ini_status = io_failure ) 
    THEN BEGIN
      IF ( inline_tracing(trace_error) <> 0 )
      THEN handle_trc_err ( TAG := tag + tagext,
                        MESSAGE := ' Failure Initializing Spec Trig #'
                                 + CONVERT(STRING,sptrgnum) 
                                 + ' Level 1.5 Scalers ' ) ;
      IF PRESENT(status) THEN status := ini_status ;
    END ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE check_alloc_sptrg_coor ( sptrgnum : INTEGER ;
                                     tagext : VARYING_STRING(8) := ''  ) ;
BEGIN

  IF ( sptrg[sptrgnum]^.allocated <> all_coor )
  THEN BEGIN
    IF ( sptrg[sptrgnum]^.status.initialized <> TRUE ) THEN
    initialize_sptrg ( SPTRGNUM:= sptrgnum,
                       TAGEXT := tagext ) ; 

    IF ( inline_tracing(trace_info) <> 0 )
    THEN handle_trc_inf ( TAG := tag + tagext,
                      MESSAGE := ' Allocating Specific Trigger ' 
                               + CONVERT(STRING,sptrgnum) + ' to COOR' ) ;

    sptrg[sptrgnum]^.allocated := all_coor ;

  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
END .