SUBROUTINE PROM_RESPONSE_ALL_INDICES ( SIGN_ETA, MAGN_ETA, PHI, & 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 possible C- indices 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- 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 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 , PAGE_INDEX_MIN:PAGE_INDEX_MAX ) C INTEGER SATURATION PARAMETER (SATURATION = 255 ) C INTEGER QUANT ( EM:PY, PAGE_INDEX_MIN:PAGE_INDEX_MAX ) INTEGER PAGE, INDEX INTEGER EM_ADC_ZERESP, HD_ADC_ZERESP INTEGER MOMENTUM_INPUT 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 INDEX = PAGE_INDEX_MIN, PAGE_INDEX_MAX QUANT ( EM, INDEX ) = NOT_MAPPED QUANT ( HD, INDEX ) = NOT_MAPPED QUANT ( PX, INDEX ) = NOT_MAPPED QUANT ( PY, INDEX ) = NOT_MAPPED END DO C DO PAGE = PAGE_NUM_MIN , PAGE_NUM_MAX QUANT ( EM, LUQ_PAGE_INDEX(EM_ET_QUANT,PAGE) ) = EM_ET_QUANT QUANT ( EM, LUQ_PAGE_INDEX(EM_L2_QUANT,PAGE) ) = EM_L2_QUANT QUANT ( HD, LUQ_PAGE_INDEX(HD_ET_QUANT,PAGE) ) = HD_ET_QUANT QUANT ( HD, LUQ_PAGE_INDEX(HD_L2_QUANT,PAGE) ) = HD_L2_QUANT QUANT ( PX, LUQ_PAGE_INDEX(PX_QUANT, PAGE) ) = PX_QUANT QUANT ( PY, LUQ_PAGE_INDEX(PY_QUANT, PAGE) ) = 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 DO INDEX = PAGE_INDEX_MIN, PAGE_INDEX_MAX C C EM lookup C IF ( QUANT ( EM, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( EM, INDEX ) = 0 ELSE LUQ_BYTE ( EM, INDEX ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,EM_PROM,INDEX) & * ADC_CORR(EM_TOWER) ) IF ( ABS( LUQ_BYTE ( EM, INDEX ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,EM_PROM,INDEX) ) & LUQ_BYTE ( EM, INDEX ) = 0 LUQ_BYTE ( EM, INDEX ) = LUQ_BYTE ( EM, INDEX ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(EM,INDEX)) IF ( LUQ_BYTE ( EM, INDEX ) .LT. 0 ) & LUQ_BYTE ( EM, INDEX ) = 0 IF ( LUQ_BYTE ( EM, INDEX ) .GT. SATURATION ) & LUQ_BYTE ( EM, INDEX ) = SATURATION END IF C C HD lookup C IF ( QUANT ( HD, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( HD, INDEX ) = 0 ELSE LUQ_BYTE ( HD, INDEX ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,HD_PROM,INDEX) & * ADC_CORR(HD_TOWER) ) IF ( ABS( LUQ_BYTE ( HD, INDEX ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,HD_PROM,INDEX) ) & LUQ_BYTE ( HD, INDEX ) = 0 LUQ_BYTE ( HD, INDEX ) = LUQ_BYTE ( HD, INDEX ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(HD,INDEX)) IF ( LUQ_BYTE ( HD, INDEX ) .LT. 0 ) & LUQ_BYTE ( HD, INDEX ) = 0 IF ( LUQ_BYTE ( HD, INDEX ) .GT. SATURATION ) & LUQ_BYTE ( HD, INDEX ) = SATURATION END IF C C Px lookup C IF ( QUANT ( PX, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( PX, INDEX ) = MOMENTUM_INPUT ELSE LUQ_BYTE ( PX, INDEX ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,PX_PROM,INDEX) & * ADC_CORR(TOT_TOWER) ) IF ( ABS( LUQ_BYTE ( PX, INDEX ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,PX_PROM,INDEX) ) & LUQ_BYTE ( PX, INDEX ) = 0 LUQ_BYTE ( PX, INDEX ) = LUQ_BYTE ( PX, INDEX ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(PX,INDEX)) IF ( LUQ_BYTE ( PX, INDEX ) .LT. 0 ) & LUQ_BYTE ( PX, INDEX ) = 0 IF ( LUQ_BYTE ( PX, INDEX ) .GT. SATURATION ) & LUQ_BYTE ( PX, INDEX ) = SATURATION END IF C C Py lookup C IF ( QUANT ( PY, INDEX ) .EQ. NOT_MAPPED ) & THEN LUQ_BYTE ( PY, INDEX ) = MOMENTUM_INPUT ELSE LUQ_BYTE ( PY, INDEX ) = & NINT( PROM_SLOPE(SIGN_ETA,MAGN_ETA,PHI,PY_PROM,INDEX) & * ADC_CORR(TOT_TOWER) ) IF ( ABS( LUQ_BYTE ( PY, INDEX ) ) & .LT. PROM_CUT(SIGN_ETA,MAGN_ETA,PHI,PY_PROM,INDEX) ) & LUQ_BYTE ( PY, INDEX ) = 0 LUQ_BYTE ( PY, INDEX ) = LUQ_BYTE ( PY, INDEX ) & + LOOKUP_ZERESP(SIGN_ETA,MAGN_ETA,PHI,QUANT(PY,INDEX)) IF ( LUQ_BYTE ( PY, INDEX ) .LT. 0 ) & LUQ_BYTE ( PY, INDEX ) = 0 IF ( LUQ_BYTE ( PY, INDEX ) .GT. SATURATION ) & LUQ_BYTE ( PY, INDEX ) = SATURATION END IF C END DO C C OPEN ( UNIT=30, FILE='DUA0:[TRIGGER]TEMP.LOG', STATUS='NEW' ) C WRITE ( 30, 1000 ) SIGN_ETA, MAGN_ETA, PHI C WRITE ( 30, 1000 ) EM_ADC_BYTE, HD_ADC_BYTE C DO INDEX = PAGE_INDEX_MIN, PAGE_INDEX_MAX C WRITE ( 30, 1000 ) LUQ_BYTE ( EM, INDEX ), C & LUQ_BYTE ( HD, INDEX ), C & LUQ_BYTE ( PX, INDEX ), C & LUQ_BYTE ( PY, INDEX ) C 1000 FORMAT ( ' ', 4I5 ) C END DO C CLOSE ( UNIT=30 ) C C---------------------------------------------------------------------- 999 RETURN END