*************************************************************************
*
* Program reductionflight.f
*
* - reads readraw.f output files: LEVEL0 ntuple, and ped, sig and bad histograms
* - decodes raw data (DATATRACKER) using DSP ped, sig and bad values
* - looks for clusters information using ped, sig and bad values from
* DSP histograms
* - fills LEVEL1 ntuple
*
*************************************************************************
subroutine reductionflight(ierror)
include 'commontracker.f'
include 'level0.f'
include 'level1.f'
include 'common_reduction.f'
include 'calib.f'
data eventn_old/nviews*0/
integer ierror
ierror = 0
c$$$ debug = .true.
c$$$ verbose = .true.
c$$$ warning = .true.
c$$$ print*,debug,verbose,warning
c$$$ debug=1
c$$$ verbose=1
c$$$ warning=1
* //////////////////////////
* initialize some parameters
* //////////////////////////
call init_level1
c debug=.true.
if(debug.eq.1)print*,'-- check LEVEL0 status'
ievco=-1
mismatch=0
c good1 = good0
c--------------------------------------------------
c check the LEVEL0 event status for missing
c sections or DSP alarms
c ==> set the variable GOOD1(12)
c--------------------------------------------------
do iv=1,nviews
if(DSPnumber(iv).gt.0.and.DSPnumber(iv).le.12)then
c ------------------------
c GOOD
c ------------------------
GOOD1(DSPnumber(iv))=0 !OK
c ------------------------
c CRC error
c ------------------------
if(crc(iv).eq.1) then
c GOOD1(DSPnumber(iv)) = 2
c GOOD1(DSPnumber(iv)) = GOOD1(DSPnumber(iv)) + 2**1
GOOD1(DSPnumber(iv)) = ior(GOOD1(DSPnumber(iv)),2**1)
102 format(' * WARNING * Event ',i7,' view',i3
$ ,' CRC error')
if(debug.eq.1)write(*,102)eventn(1),DSPnumber(iv)
c goto 18 !next view
endif
c ------------------------
c online-software alarm
c ------------------------
if(
$ fl1(iv).ne.0.or.
$ fl2(iv).ne.0.or.
$ fl3(iv).ne.0.or.
$ fl4(iv).ne.0.or.
$ fl5(iv).ne.0.or.
$ fl6(iv).ne.0.or.
$ fc(iv).ne.0.or.
$ DATAlength(iv).eq.0.or.
$ .false.)then
c GOOD1(DSPnumber(iv))=3
c GOOD1(DSPnumber(iv)) = GOOD1(DSPnumber(iv)) + 2**2
GOOD1(DSPnumber(iv)) = ior(GOOD1(DSPnumber(iv)),2**2)
103 format(' * WARNING * Event ',i7,' view',i3
$ ,' software alarm')
if(debug.eq.1)write(*,103)eventn(1),DSPnumber(iv)
c goto 18
endif
c ------------------------
c DSP-counter jump
c ------------------------
c commentato perche` non e` un controllo significativo nel caso in cui
c la subroutine venga chiamata per riprocessare l'evento
c sostituito con un check dei contatori dei vari dsp
c$$$ if(
c$$$ $ eventn_old(iv).ne.0.and. !first event in this file
c$$$ $ eventn(iv).ne.1.and. !first event in run
c$$$ $ good_old(DSPnumber(iv)).ne.0.and. !previous event corrupted
c$$$ $ .true.)then
c$$$
c$$$ if(eventn(iv).ne.(eventn_old(iv)+1))then
c$$$c GOOD1(DSPnumber(iv))=4
c$$$c GOOD1(DSPnumber(iv)) = GOOD1(DSPnumber(iv)) + 2**3
c$$$ GOOD1(DSPnumber(iv)) = ior(GOOD1(DSPnumber(iv)),2**3)
c$$$ 104 format(' * WARNING * Event ',i7,' view',i3
c$$$ $ ,' counter jump ',i10,i10)
c$$$ if(debug.eq.1)write(*,104)eventn(1),DSPnumber(iv)
c$$$ $ ,eventn_old(iv),eventn(iv))
c$$$ goto 18
c$$$ endif
c$$$
c$$$ endif
c ------------------------
c 18 continue
c ------------------------
c DSP-counter
c ------------------------
if( DSPnumber(iv).ne.0.and.GOOD1(DSPnumber(iv)).ne.1)then
if(iv.ne.1.and.ievco.ne.-1)then
if( eventn(iv).ne.ievco )then
mismatch=1
endif
endif
ievco = eventn(iv)
endif
endif
enddo
c print*,'*** ',(eventn(iv),iv=1,12)
if(mismatch.eq.1.and.debug.eq.1)
$ print*,' * WARNING * DSP counter mismatch: '
$ ,(eventn(iv),iv=1,12)
ngood = 0
do iv = 1,nviews
if(mismatch.eq.1.and.GOOD1(iv).ne.1)
$ GOOD1(iv)=ior(GOOD1(iv),2**3)
eventn_old(iv) = eventn(iv)
good_old(iv) = good1(iv)
ngood = ngood + good1(iv)
enddo
c$$$ if(verbose.and.ngood.ne.0)print*,'* WARNING * Event ',eventn(1)
c$$$ $ ,':LEVEL0 event status: '
c$$$ $ ,(good1(i),i=1,nviews)
c--------------------------------------------------
c read the variable DATATRACKER from LEVEL0
c and fill the variable ADC (invertin view 11)
c--------------------------------------------------
if(debug.eq.1)print*,'-- fill ADC vectors'
call filladc(iflag)
if(iflag.ne.0)then
ierror = 220
endif
c--------------------------------------------------
c computes common noise for each VA1
c (excluding strips with signal,
c tagged with the flag CLSTR)
c--------------------------------------------------
if(debug.eq.1)print*,'-- compute CN'
do iv=1,nviews
call evaluatecn(iv)
c$$$ ima=0
c$$$ do ik=1,nva1_view
c$$$ cn(iv,ik) = 0
c$$$ cnrms(iv,ik) = 0
c$$$ cnn(iv,ik) = -1
c$$$ iflag = 0
c$$$ mask_vk_ev(iv,ik) = 1
c$$$ call stripmask(iv,ik) !compute mask(i,j,k), combining VA1-masks
c$$$* --------------------------------------
c$$$* if chip is not masked ---> evaluate CN
c$$$* --------------------------------------
c$$$ if( mask(iv,ik,1).eq.1 ) then !!!NBNB mask per la striscia 1 !!!!!!!!
c$$$ call cncomp(iv,ik,iflag)
c$$$ if(iflag.ne.0)then
c$$$ ima=ima+1
c$$$ mask_vk_ev(iv,ik)=0
c$$$ ierror = 220
c$$$ endif
c$$$ call stripmask(iv,ik) !compute mask(i,j,k), combining VA1-masks
c$$$ endif
c$$$ enddo
c$$$ 100 format(' * WARNING * Event ',i7,' view',i3,': VK MASK ',24i1)
c$$$ if(ima.ne.0.and.verbose.eq.1)write(*,100)eventn(1),iv
c$$$ $ ,(mask_vk_ev(iv,ik),ik=1,nva1_view)
enddo
cc call stripmask !compute mask(i,j,k), combining mask_vk_ev and mask_vk
c---------------------------------------------
c loops on views, VA1 and strips,
c and computes strips signals using
c badstrip, pedestals, and
c sigma informations from histograms
c---------------------------------------------
ind=1 !clsignal array index
if(debug.eq.1)print*,'-- search clusters'
do iv=1,nviews !loop on views
c$$$ do is=1,nstrips_view !loop on strips (1)
c$$$ if(mod(iv,2).eq.1) then
c$$$C=== > Y view
c$$$c print*,iv,nvk(is),nst(is),adc(iv,nvk(is),nst(is))
c$$$c $ ,cn(iv,nvk(is))
c$$$c $ ,pedestal(iv,nvk(is),nst(is))
c$$$ value(is)= -(DBLE(adc(iv,nvk(is),nst(is)))
c$$$ $ -cn(iv,nvk(is))-pedestal(iv,nvk(is),nst(is)))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ clseedcut(is)=clcuty*sigma(iv,nvk(is),nst(is))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ clinclcut(is)=incuty*sigma(iv,nvk(is),nst(is))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ sat(is)=0
c$$$ if( adc(iv,nvk(is),nst(is)).lt.adc_saty )sat(is)=1
c$$$ else
c$$$C=== > X view
c$$$ value(is)= (DBLE(adc(iv,nvk(is),nst(is)))
c$$$ $ -cn(iv,nvk(is))-pedestal(iv,nvk(is),nst(is)))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ clseedcut(is)=clcutx*sigma(iv,nvk(is),nst(is))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ clinclcut(is)=incutx*sigma(iv,nvk(is),nst(is))
c$$$ $ *mask(iv,nvk(is),nst(is))
c$$$ sat(is)=0
c$$$ if( adc(iv,nvk(is),nst(is)).gt.adc_satx )sat(is)=1
c$$$ endif
c$$$ enddo !end loop on strips (1)
call subtractped(iv)
call searchcluster(iv)
if(.not.flag_shower)then
call savecluster(iv)
if(debug.eq.1)print*,'view ',iv,' #clusters ', nclstr_view
else
fshower(iv) = 1
c GOOD1(DSPnumber(iv)) = 11 !AHAHAHAHA ORRORE!!
c GOOD1(iv) = 11
c GOOD1(iv) = GOOD1(iv) + 2**5
GOOD1(iv) = ior(GOOD1(iv),2**5)
101 format(' * WARNING * Event ',i7,' view',i3
$ ,' #clusters > ',i5,' --> MASKED')
if(verbose.eq.1)write(*,101)eventn(1),iv,nclstrmax_view
endif
enddo ! end loop on views
do iv=1,nviews
do ik=1,nva1_view
cnev(iv,ik) = cn(iv,ik) !assigns computed CN to ntuple variables
cnrmsev(iv,ik) = cnrms(iv,ik) !assigns computed CN to ntuple variables
cnnev(iv,ik) = cnn(iv,ik) !assigns computed CN to ntuple variables
enddo
enddo
C---------------------------------------------
C come here if GOOD1=0
C or the event has too many clusters
C---------------------------------------------
c 200 continue
ngood = 0
do iv = 1,nviews
ngood = ngood + good1(iv)
enddo
if(verbose.eq.1.and.ngood.ne.0)
$ print*,'* WARNING * Event ',eventn(1)
$ ,':LEVEL1 event status: '
$ ,(good1(i),i=1,nviews)
c------------------------------------------------------------------------
c
c closes files and exits
c
c------------------------------------------------------------------------
RETURN
END
***...***...***...***...***...***...***...***...***...***...***...***...***...***...***...***
*
*
*
*
*
*
*
*
*
***...***...***...***...***...***...***...***...***...***...***...***...***...***...***...***
subroutine init_level1
include 'commontracker.f'
include 'level1.f'
include 'level0.f'
c good1 = 0
do iv=1,12
good1(iv) = 1 !missing packet
enddo
nclstr1 = 0
totCLlength = 0
do ic=1,nclstrmax
view(ic) = 0
ladder(ic) = 0
indstart(ic) = 0
indmax(ic) = 0
maxs(ic) = 0
mult(ic) = 0
sgnl(ic) = 0
whichtrack(ic) = 0 !assigned @ level2
enddo
do id=1,maxlength !???
clsignal(id) = 0.
clsigma(id) = 0.
cladc(id) = 0 ! EM GCC4.7 is integer
clbad(id) = 0 ! EM GCC4.7 is integer
enddo
do iv=1,nviews
c crc1(iv)=0
do ik=1,nva1_view
cnev(iv,ik) = 0
cnnev(iv,ik) = 0
enddo
fshower(iv) = 0
enddo
return
end
*---***---***---***---***---***---***---***---***
*
*
*
*
*
*---***---***---***---***---***---***---***---***
subroutine searchcluster(iv)
include 'commontracker.f'
include 'level0.f'
include 'level1.f'
include 'calib.f'
include 'common_reduction.f'
c local variables
integer rmax,lmax !estremi del cluster
integer rstop,lstop
integer first,last
integer fsat,lsat
external nst
iseed=-999 !cluster seed index initialization
inext=-999 !index where to start new cluster search
flag_shower = .false.
nclstr_view=0
do jl=1,nladders_view !1..3 !loops on ladders
first = 1+nstrips_ladder*(jl-1) !1,1025,2049
last = nstrips_ladder*jl !1024,2048,3072
* X views have 1018 strips instead of 1024
if(mod(iv,2).eq.0) then
first=first+3
last=last-3
endif
do is=first,last !loop on strips in each ladder
c---------------------------------------------
c new-cluster search starts at index inext
c---------------------------------------------
if(is.lt.inext) goto 220 ! next strip
if(value(is).gt.clseedcut(is)) then
c-----------------------------------------
c possible SEED...
c-----------------------------------------
itemp = is
fsat = 0 ! first saturated strip
lsat = 0 ! last saturated strip
if(itemp.eq.last) goto 230 !estremo...
c ------------------------
c search for first maximum
c ------------------------
do while(
$ value(itemp).le.value(itemp+1)
$ .and.value(itemp+1).gt.clseedcut(itemp+1))
itemp = itemp+1
if(itemp.eq.last) goto 230 !stops if reaches last strip
if(sat(itemp).eq.1) goto 230 !stop if reaches a saturated strip
enddo ! of the ladder
230 continue
c -----------------------------
c check if strips are saturated
c -----------------------------
if( sat(itemp).eq.1 )then
fsat = itemp
lsat = itemp
if(itemp.eq.last) goto 231 !estremo...
do while( sat(itemp+1).eq.1 )
itemp = itemp+1
lsat = itemp
if(itemp.eq.last) goto 231 !stops if reaches last strip
enddo
endif
231 continue
c---------------------------------------------------------------------------
c fownd SEED!!!
c (if there are saturated strips, the cluster is centered in the middle)
c---------------------------------------------------------------------------
if(fsat.eq.0.and.lsat.eq.0)then
iseed = itemp ! <<< SEED
else
iseed = int((lsat+fsat)/2) ! <<< SEED
c$$$ print*,'saturated strips ',fsat,lsat,iseed
c$$$ print*,'--> ',(value(ii),ii=fsat,lsat)
endif
c---------------------------------------------------------------
c after finding a cluster seed, checks also adjacent strips,
C and tags the ones exceeding clinclcut
c---------------------------------------------------------------
ir=iseed !indici destro
il=iseed ! e sinistro
rmax=ir !estremo destro del cluster
lmax=il ! e sinistro
rstop=0 !initialize flags used to exit from
lstop=0 ! inclusion loop
do while(lstop.eq.0.or.rstop.eq.0) !shifts left and right from
ir=ir+1 !index for right side
il=il-1 !index for left side
c------------------------------------------------------------------------
c checks for last or first strip of the ladder
c------------------------------------------------------------------------
if( ir.gt.last ) rstop = 1
if( il.lt.first ) lstop = 1
c------------------------------------------------------------------------
c add strips exceeding inclusion cut
c------------------------------------------------------------------------
if( (rmax-lmax+1).ge.nclstrp )goto 210 !exits inclusion loop
if(rstop.eq.0) then !if right cluster border has not been reached
if(value(ir).gt.clinclcut(ir)) then
rmax=ir !include a strip on the right
else
rstop=1 !cluster right end
endif
endif
if( (rmax-lmax+1).ge.nclstrp )goto 210 !exits inclusion loop
if(lstop.eq.0) then !if left cluster border has not been reached
if(value(il).gt.clinclcut(il)) then
lmax=il !include a strip on the left
else
lstop=1 !cluster left end
endif
endif
c if( (rmax-lmax+1).ge.nclstrp )goto 210 !exits inclusion loop
enddo !ends strip inclusion loop
goto 211
210 continue !jumps here if more than nclstrp have been included
c print*,'>>> nclstrp! '
211 continue
c-----------------------------------------
c end of inclusion loop!
c-----------------------------------------
c------------------------------------------------------------------------
c adjust the cluster in order to have at least a strip around the seed
c------------------------------------------------------------------------
if(iseed.eq.lmax.and.lmax.ne.first)then
lmax = lmax-1
if( (rmax-lmax+1).gt.nclstrp )rmax=rmax-1
endif
if(iseed.eq.rmax.and.rmax.ne.last )then
rmax = rmax+1
if( (rmax-lmax+1).gt.nclstrp )lmax=lmax+1
endif
c-------------------------------------------------------------------------------
c adjust the cluster in order to have at least ANOTHER strip around the seed
c-------------------------------------------------------------------------------
if(iseed-1.eq.lmax.and.lmax.ne.first)then
lmax = lmax-1
if( (rmax-lmax+1).gt.nclstrp )rmax=rmax-1
endif
if(iseed+1.eq.rmax.and.rmax.ne.last )then
rmax = rmax+1
if( (rmax-lmax+1).gt.nclstrp )lmax=lmax+1
endif
c---------------------------------------------------
c now we have 5 stored-strips around the maximum
c---------------------------------------------------
c------------------------------------------------------------------------
c adjust the cluster in order to store a minimum number of strips
c------------------------------------------------------------------------
do while( (rmax-lmax+1).lt.nclstrpmin )
vl = -99999
vr = -99999
if(lmax-1.ge.first) vl = value(lmax-1)
if(rmax+1.le.last ) vr = value(rmax+1)
if(vr.ge.vl) then
rmax = rmax+1
else
lmax = lmax-1
endif
enddo
c--------------------------------------------------------
c store cluster info
c--------------------------------------------------------
nclstr_view = nclstr_view + 1 !cluster number
if(nclstr_view.gt.nclstrmax_view) then !too many clusters for the view:
c$$$ if(verbose) print*,'Event ',eventn(1),
c$$$ $ ': more than ',nclstrmax_view
c$$$ $ ,' clusters on view ',iv
flag_shower = .true.
goto 2000
endif
ladder_view(nclstr_view) = nld(iseed,iv)
maxs_view(nclstr_view) = iseed
rmax_view(nclstr_view) = rmax
lmax_view(nclstr_view) = lmax
c mult_view(nclstr_view) = rmax-lmax+1
mult_view(nclstr_view) = 0
do ii=lmax,rmax
if(value(ii).gt.clinclcut(ii))
$ mult_view(nclstr_view) = mult_view(nclstr_view)+1
enddo
c$$$ if(rmax-lmax+1.gt.25)
c$$$ $ print*,'view ',iv
c$$$ $ ,' cl ',nclstr_view,' mult ',rmax-lmax+1
c------------------------------------------------------------------------
c search for a double peak inside the cluster
c------------------------------------------------------------------------
inext = rmax+1 !<< index where to start new-cluster search
vmax = 0
vmin = value(iseed)
imax = iseed
imin = iseed
do iss = max(iseed+1,lsat+1),rmax
if( value(iss).lt.vmin )then
if( imax.ne.iseed )goto 221 !found dowble peek
imin = iss
vmin = value(iss)
else
delta = value(iss) - value(imin)
cut = sqrt(clinclcut(iss)**2 + clinclcut(imin)**2)
if(
$ delta.gt.cut .and.
$ value(iss).gt.clseedcut(iss).and.
$ .true.)then
if( value(iss).gt.vmax )then
imax = iss
vmax = value(iss)
else
goto 221 !found dowble peek
endif
endif
endif
enddo
221 continue
if(imax.gt.iseed)then
inext = imax !<< index where to start new-cluster search
c$$$ print*,'--- double peek ---'
c$$$ print*,(value(ii),ii=lmax,rmax)
c$$$ print*,'seed ',iseed,' imin ',imin,' imax ',imax
endif
c--------------------------------------------------------
c
c--------------------------------------------------------
endif !end possible seed conditio
220 continue !jumps here to skip strips left of last seed
enddo ! end loop on strips
enddo !end loop on ladders
2000 continue
return
end
*---***---***---***---***---***---***---***---***
*
*
*
*
*
*---***---***---***---***---***---***---***---***
subroutine savecluster(iv)
*
* (080/2006 Elena Vannuccini)
* Save the clusters view by view
include 'commontracker.f'
include 'level1.f'
include 'calib.f'
include 'common_reduction.f'
integer CLlength !lunghezza in strip del cluster
do ic=1,nclstr_view
nclstr1 = nclstr1+1
view(nclstr1) = iv
ladder(nclstr1) = ladder_view(ic)
maxs(nclstr1) = maxs_view(ic)
mult(nclstr1) = mult_view(ic)
c posizione dell'inizio del cluster nell' array clsignal
indstart(nclstr1) = ind
c posizione del cluster seed nell'array clsignal
indmax(nclstr1) = indstart(nclstr1)
$ +( maxs_view(ic) - lmax_view(ic) )
CLlength = rmax_view(ic) - lmax_view(ic) + 1 !numero di strip salvate
totCLlength = totCLlength + CLlength
sgnl(nclstr1) = 0
do j=lmax_view(ic),rmax_view(ic) !stores sequentially cluter strip values in
clsignal(ind) = value(j) ! clsignal array
c$$$ print*,ind,clsignal(ind)
ivk=nvk(j)
ist=nst(j)
clsigma(ind) = sigma(iv,ivk,ist)
cladc(ind) = int(adc(iv,ivk,ist)) ! EM GCC4.7 is integer
clbad(ind) = bad(iv,ivk,ist)
c clped(ind) = pedestal(iv,ivk,ist)
ind=ind+1
c if(value(j).gt.0)
if(value(j).gt.clinclcut(j))
$ sgnl(nclstr1) = sgnl(nclstr1) + value(j) !cluster charge
enddo
c$$$ print*,'view ',iv,' -- savecluster -- nclstr1: '
c$$$ $ ,nclstr1,maxs(nclstr1),mult(nclstr1),sgnl(nclstr1)
c$$$ print*,'----------------------'
enddo
return
end
*---***---***---***---***---***---***---***---***
*
*
*
*
*
*---***---***---***---***---***---***---***---***
subroutine evaluatecn(iv)
include 'commontracker.f'
include 'level0.f'
include 'level1.f'
include 'common_reduction.f'
include 'calib.f'
ima=0
do ik=1,nva1_view
cn(iv,ik) = 0
cnrms(iv,ik) = 0
cnn(iv,ik) = -1
iflag = 0
mask_vk_ev(iv,ik) = 1
call stripmask(iv,ik) !compute mask(i,j,k), combining VA1-masks
* --------------------------------------
* if chip is not masked ---> evaluate CN
* --------------------------------------
if( mask(iv,ik,1).eq.1 ) then !!!NBNB mask per la striscia 1 !!!!!!!!
call cncomp(iv,ik,iflag)
if(iflag.ne.0)then
ima=ima+1
mask_vk_ev(iv,ik)=0
ierror = 220
endif
call stripmask(iv,ik) !compute mask(i,j,k), combining VA1-masks
endif
enddo
100 format(' * WARNING * Event ',i7,' view',i3,': VK MASK ',24i1)
if(ima.ne.0.and.verbose.eq.1)write(*,100)eventn(1),iv
$ ,(mask_vk_ev(iv,ik),ik=1,nva1_view)
return
end
*---***---***---***---***---***---***---***---***
*
*
*
*
*
*---***---***---***---***---***---***---***---***
subroutine subtractped(iv)
include 'commontracker.f'
include 'level1.f'
include 'calib.f'
include 'common_reduction.f'
do is=1,nstrips_view !loop on strips (1)
if(mod(iv,2).eq.1) then
C=== > Y view
c print*,iv,nvk(is),nst(is),adc(iv,nvk(is),nst(is))
c $ ,cn(iv,nvk(is))
c $ ,pedestal(iv,nvk(is),nst(is))
value(is)= -(REAL(adc(iv,nvk(is),nst(is))) ! EM GCC4.7 value(nstrips_view) is real not double
$ -cn(iv,nvk(is))-pedestal(iv,nvk(is),nst(is)))
$ *mask(iv,nvk(is),nst(is))
clseedcut(is)=clcuty*sigma(iv,nvk(is),nst(is))
$ *mask(iv,nvk(is),nst(is))
clinclcut(is)=incuty*sigma(iv,nvk(is),nst(is))
$ *mask(iv,nvk(is),nst(is))
sat(is)=0
if( adc(iv,nvk(is),nst(is)).lt.adc_saty )sat(is)=1
else
C=== > X view
value(is)= (REAL(adc(iv,nvk(is),nst(is)))
$ -cn(iv,nvk(is))-pedestal(iv,nvk(is),nst(is)))
$ *mask(iv,nvk(is),nst(is))
clseedcut(is)=clcutx*sigma(iv,nvk(is),nst(is))
$ *mask(iv,nvk(is),nst(is))
clinclcut(is)=incutx*sigma(iv,nvk(is),nst(is))
$ *mask(iv,nvk(is),nst(is))
sat(is)=0
if( adc(iv,nvk(is),nst(is)).gt.adc_satx )sat(is)=1
endif
enddo !end loop on strips (1)
return
end
*---***---***---***---***---***---***---***---***
*
*
*
*
*
*---***---***---***---***---***---***---***---***
c$$$ subroutine stripmask
c$$$
c$$$* this routine set va1 and single-strip masks,
c$$$* on the basis of the VA1 mask saved in the DB
c$$$*
c$$$* mask(nviews,nva1_view,nstrips_va1) !strip mask
c$$$* mask_vk(nviews,nva1_view) !VA1 mask
c$$$*
c$$$ include 'commontracker.f'
c$$$ include 'level1.f'
c$$$ include 'common_reduction.f'
c$$$ include 'calib.f'
c$$$
c$$$* init mask
c$$$ do iv=1,nviews
c$$$ do ivk=1,nva1_view
c$$$ do is=1,nstrips_va1
c$$$c mask(iv,ivk,is) = mask_vk(iv,ivk)
c$$$ if( mask_vk(iv,ivk) .ne. -1)then
c$$$ mask(iv,ivk,is) = 1
c$$$ $ * mask_vk(iv,ivk) !from DB
c$$$ $ * mask_vk_ev(iv,ivk) !from <SIG>
c$$$ $ * mask_vk_run(iv,ivk) !from CN
c$$$ else
c$$$ mask(iv,ivk,is) = -1
c$$$ $ * mask_vk(iv,ivk) !from DB
c$$$ $ * mask_vk_ev(iv,ivk) !from CN
c$$$ endif
c$$$ enddo
c$$$ enddo
c$$$ enddo
c$$$
c$$$
c$$$ return
c$$$ end
subroutine stripmask(iv,ivk)
* -----------------------------------------------
* this routine set va1 and single-strip masks,
* on the basis of the VA1 mask saved in the DB
*
* mask(nviews,nva1_view,nstrips_va1) !strip mask
* mask_vk(nviews,nva1_view) !VA1 mask
* -----------------------------------------------
include 'commontracker.f'
include 'level1.f'
include 'common_reduction.f'
include 'calib.f'
* init mask
do is=1,nstrips_va1
* --------------------------------------------------------
* if VA1-mask from DB is 0 or 1, three masks are combined:
* - from DB (a-priori mask)
* - run-based (chip declared bad on the basis of <SIG>)
* - event-based (failure in CN computation)
* --------------------------------------------------------
c print*,iv,ivk
c $ ,mask_vk(iv,ivk),mask_vk_ev(iv,ivk),mask_vk_run(iv,ivk)
if( mask_vk(iv,ivk) .ne. -1)then
mask(iv,ivk,is) = 1
$ * mask_vk(iv,ivk) !from DB
$ * mask_vk_ev(iv,ivk) !from <SIG>
$ * mask_vk_run(iv,ivk) !from CN
* -----------------------------------------------------------
* if VA1-mask from DB is -1 only event-based mask is applied
* -----------------------------------------------------------
else
mask(iv,ivk,is) = -1
$ * mask_vk(iv,ivk) !from DB
$ * mask_vk_ev(iv,ivk) !from CN
endif
enddo
return
end