SUBROUTINE PROM_RESPONSE_BY_INDEX ( SIGN_ETA, MAGN_ETA, PHI, & INDEX, & EM_ADC_BYTE, HD_ADC_BYTE, & LUQ_BYTE ) C---------------------------------------------------------------------- C- C- Purpose and Methods : Reconstruct the set of prom responses for the C- specified set of ADC bytes, and for all the C- requested index. C- C- Inputs : C- SIGN_ETA is the sign of the eta index of the trigger C- tower for which the PROM response is reconstructed. C- Use 0 to specify a negative eta index, 1 to C- specify a positive eta index. C- It is recommended to use one of the compilation C- constants defined along with the common block. C- POS_ETA=0 or NEG_ETA=1. C- C- MAGN_ETA is the magnitutde of the eta index of the C- trigger tower for which the PROM response C- is reconstructed. C- Range : 1 to 24 C- C- PHI is the phi index of the trigger tower for C- which the PROM response is reconstructed. C- Range : 1 to 32 C- C- INDEX is the PROM page index for which the C- PROM response is reconstructed. C- C- EM_ADC_BYTE is the ADC output byte (simulated or from First C- Level Trigger Data Block information) of the C- ELectro-Magnetic Trigger Tower for which the C- PROM response is reconstructed. C- C- HD_ADC_BYTE is the ADC output byte (simulated or from First C- Level Trigger Data Block information) of the C- Hadronic Trigger Tower for which the C- PROM response is reconstructed. C- C- Outputs : C- LUQ_BYTE is the expected set of PROM ouptuts for all of the C- constructed quantities. C- C- Comments : C- A call to INIT_LOOKUP_ROUTINES must have been made C- before this routine can be called. C- C- The subroutine will return a zero in any value for C- which the lookup (or the tower) is not implemented. C- This simulation will take into account any scale C- shift performed by the PROM. C- This simulation will take into account any low C- energy cutoff performed by the PROM. C- This simulation will take into account any input or C- output offset handled by the PROM. C- This simulation will take into account the fine C- tuning "Tweak" of each lookup page. C- C- Created 16-NOV-1990 MICHIGAN STATE UNIVERSTITY, TRIGGER CONTROL SOFTWARE C---------------------------------------------------------------------- IMPLICIT NONE C INCLUDE 'D0$LEVEL1:LEVEL1_LOOKUP.PARAMS' INCLUDE 'D0$LEVEL1:LEVEL1_LOOKUP.INC' C INTEGER SIGN_ETA, MAGN_ETA, PHI INTEGER INDEX INTEGER MOMENTUM_INPUT INTEGER EM_ADC_BYTE, HD_ADC_BYTE INTEGER NOT_MAPPED, EM, HD, PX, PY PARAMETER (NOT_MAPPED = 0, EM = 1, HD = 2, PX = 3, PY = 4 ) INTEGER LUQ_BYTE ( EM:PY ) C INTEGER SATURATION PARAMETER (SATURATION = 255 ) C INTEGER QUANT ( EM:PY, PAGE_INDEX_MIN:PAGE_INDEX_MAX ) INTEGER LUPAGE, PAGE_INDEX INTEGER EM_ADC_ZERESP, HD_ADC_ZERESP REAL ADC_CORR(EM_TOWER:TOT_TOWER) C LOGICAL FIRST SAVE FIRST DATA FIRST /.TRUE./ C C---------------------------------------------------------------------- C C For first call, put together an array of which quantity C is associated with each page index C IF ( FIRST .EQ. .TRUE. ) THEN C DO PAGE_INDEX = PAGE_INDEX_MIN, PAGE_INDEX_MAX QUANT ( EM, PAGE_INDEX ) = NOT_MAPPED QUANT ( HD, PAGE_INDEX ) = NOT_MAPPED QUANT ( PX, PAGE_INDEX ) = NOT_MAPPED QUANT ( PY, PAGE_INDEX ) = NOT_MAPPED END DO C DO LUPAGE = PAGE_NUM_MIN , PAGE_NUM_MAX QUANT ( EM, LUQ_PAGE_INDEX(EM_ET_QUANT,LUPAGE) ) = EM_ET_QUANT QUANT ( EM, LUQ_PAGE_INDEX(EM_L2_QUANT,LUPAGE) ) = EM_L2_QUANT QUANT ( HD, LUQ_PAGE_INDEX(HD_ET_QUANT,LUPAGE) ) = HD_ET_QUANT QUANT ( HD, LUQ_PAGE_INDEX(HD_L2_QUANT,LUPAGE) ) = HD_L2_QUANT QUANT ( PX, LUQ_PAGE_INDEX(PX_QUANT, LUPAGE) ) = PX_QUANT QUANT ( PY, LUQ_PAGE_INDEX(PY_QUANT, LUPAGE) ) = PY_QUANT END DO C FIRST = .FALSE. C END IF C C Remove offsets and convert to floating point C EM_ADC_ZERESP = ADC_ZERESP(SIGN_ETA,MAGN_ETA,PHI,EM_TOWER) HD_ADC_ZERESP = ADC_ZERESP(SIGN_ETA,MAGN_ETA,PHI,HD_TOWER) ADC_CORR(EM_TOWER) = FLOAT( EM_ADC_BYTE - EM_ADC_ZERESP ) ADC_CORR(HD_TOWER) = FLOAT( HD_ADC_BYTE - HD_ADC_ZERESP ) C Px and Py PROMs receive the highest 8 bits of the 9 bit (EM+HD) MOMENTUM_INPUT = (EM_ADC_BYTE + HD_ADC_BYTE) / 2 ADC_CORR(TOT_TOWER) = FLOAT( MOMENTUM_INPUT ) & - FLOAT( EM_ADC_ZERESP + HD_ADC_ZERESP ) / 2.0 & + 0.25 C C EM lookup C IF ( QUANT ( EM, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( EM ) = 0 ELSE LUQ_BYTE ( EM ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,EM_PROM,INDEX) & * ADC_CORR(EM_TOWER) ) IF ( ABS( LUQ_BYTE ( EM ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,EM_PROM,INDEX) ) & LUQ_BYTE ( EM ) = 0 LUQ_BYTE ( EM ) = LUQ_BYTE ( EM ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(EM,INDEX)) IF ( LUQ_BYTE ( EM ) .LT. 0 ) & LUQ_BYTE ( EM ) = 0 IF ( LUQ_BYTE ( EM ) .GT. SATURATION ) & LUQ_BYTE ( EM ) = SATURATION END IF C C HD lookup C IF ( QUANT ( HD, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( HD ) = 0 ELSE LUQ_BYTE ( HD ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,HD_PROM,INDEX) & * ADC_CORR(HD_TOWER) ) IF ( ABS( LUQ_BYTE ( HD ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,HD_PROM,INDEX) ) & LUQ_BYTE ( HD ) = 0 LUQ_BYTE ( HD ) = LUQ_BYTE ( HD ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(HD,INDEX)) IF ( LUQ_BYTE ( HD ) .LT. 0 ) & LUQ_BYTE ( HD ) = 0 IF ( LUQ_BYTE ( HD ) .GT. SATURATION ) & LUQ_BYTE ( HD ) = SATURATION END IF C C Px lookup C IF ( QUANT ( PX, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( PX ) = MOMENTUM_INPUT ELSE LUQ_BYTE ( PX ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,PX_PROM,INDEX) & * ADC_CORR(TOT_TOWER) ) IF ( ABS( LUQ_BYTE ( PX ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,PX_PROM,INDEX) ) & LUQ_BYTE ( PX ) = 0 LUQ_BYTE ( PX ) = LUQ_BYTE ( PX ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(PX,INDEX)) IF ( LUQ_BYTE ( PX ) .LT. 0 ) & LUQ_BYTE ( PX ) = 0 IF ( LUQ_BYTE ( PX ) .GT. SATURATION ) & LUQ_BYTE ( PX ) = SATURATION END IF C C Py lookup C IF ( QUANT ( PY, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( PY ) = MOMENTUM_INPUT ELSE LUQ_BYTE ( PY ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,PY_PROM,INDEX) & * ADC_CORR(TOT_TOWER) ) IF ( ABS( LUQ_BYTE ( PY ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,PY_PROM,INDEX) ) & LUQ_BYTE ( PY ) = 0 LUQ_BYTE ( PY ) = LUQ_BYTE ( PY ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(PY,INDEX)) IF ( LUQ_BYTE ( PY ) .LT. 0 ) & LUQ_BYTE ( PY ) = 0 IF ( LUQ_BYTE ( PY ) .GT. SATURATION ) & LUQ_BYTE ( PY ) = SATURATION END IF C C---------------------------------------------------------------------- 999 RETURN END