****************************************************************** * Ntuple ID = 1 Entries = 505 PNN ntup ****************************************************************** * Var numb * Type * Packing * Range * Block * Name * ****************************************************************** * 1 * U*4 * 16 * [40000,60000 * P1BASIC * run * 2 * U*4 * 21 * [0,2000000] * P1BASIC * event * 3 * U*4 * 17 * [0,100000] * P1BASIC * splno * 4 * U*4 * 17 * [0,100000] * P1BASIC * splrec * 5 * U*4 * 13 * [0,4096] * P1BASIC * ev_spill * 6 * R*4 * 8 * [0.,5.] * P1BASIC * scal_tsp * 7 * R*4 * 8 * [0.,5.] * P1BASIC * scal_io2 * 8 * R*4 * 8 * [0.,5.] * P1BASIC * scal_io3 * 9 * R*4 * 12 * [9.,11.] * P1BASIC * utbfld * 10 * L*4 * 1 * * P1BASIC * skim(10) * 11 * L*4 * 1 * * P1BASIC * cut(100) * 12 * U*4 * 7 * [0,100] * P1BASIC * icut * 13 * I*4 * 6 * [-1,22] * P1BASIC * lay * 14 * I*4 * 6 * [-1,22] * P1BASIC * tlay * 15 * I*4 * 6 * [-1,25] * P1BASIC * sec * 16 * I*4 * 6 * [-3,25] * P1BASIC * tsec * 17 * I*4 * 6 * [-3,25] * P1BASIC * ssec * 18 * U*4 * 3 * [0,7] * P1BASIC * thex * 19 * I*4 * 6 * [-1,25] * P1BASIC * t2sec * 20 * I*4 * 6 * [-1,25] * P1BASIC * rssec1 * 21 * I*4 * 6 * [-1,25] * P1BASIC * rssec2 * 22 * R*4 * 11 * [-80.,80.] * P1BASIC * rsdt1 * 23 * R*4 * 10 * [-80.,80.] * P1BASIC * rsdt2 * 24 * R*4 * 10 * [-20.,80.] * P1BASIC * trs * 25 * R*4 * 11 * [0.,500.] * P1BASIC * erd * 26 * L*4 * 1 * * P1BASIC * lct(21) * 27 * L*4 * 1 * * P1BASIC * ext(25) * 28 * L*4 * 1 * * P1BASIC * lev0(16) * 29 * L*4 * 1 * * P1BASIC * lhex * 30 * L*4 * 1 * * P1BASIC * hhex(6) * 31 * L*4 * 1 * * P1BASIC * l0z * 32 * L*4 * 1 * * P1BASIC * l11 * 33 * L*4 * 1 * * P1BASIC * l12 * 34 * R*4 * 8 * [-32.,32.] * P1BASIC * tavgz * 35 * R*4 * 5 * [0.,15.] * P1BASIC * tntg * 36 * R*4 * 11 * [0.,300.] * P1BASIC * rsintime * 37 * L*4 * 1 * * P1BASIC * ustop_hex * 38 * R*4 * 10 * [-20.,80.] * P1BASIC * tdcds * 1 * U*4 * 5 * [0,31] * P1TDOUT * ipiflg * 2 * R*4 * 9 * [0.,100.] * P1TDOUT * cmupi1(2) * 3 * R*4 * 12 * [0.,120.] * P1TDOUT * tmuon1(2) * 4 * R*4 * 12 * [0.,1000.] * P1TDOUT * emuon1(2) * 5 * R*4 * 12 * [0.,20.] * P1TDOUT * emuonc1(2) * 6 * R*4 * 12 * [-30.,30.] * P1TDOUT * dt1 * 7 * R*4 * 9 * [0.,1000.] * P1TDOUT * emut1 * 8 * R*4 * 12 * [0.,20.] * P1TDOUT * emutc1 * 9 * R*4 * 16 * [0.,1000.] * P1TDOUT * prod1 * 10 * R*4 * 12 * [0.,120.] * P1TDOUT * tmuav1 * 11 * R*4 * 7 * [-5.,20.] * P1TDOUT * muped1(2) * 12 * R*4 * 7 * [-5.,20.] * P1TDOUT * piped1(2) * 13 * R*4 * 16 * [0.,2000.] * P1TDOUT * cmuend1(2) * 14 * R*4 * 16 * [0.,2000.] * P1TDOUT * cpiend1(2) * 15 * R*4 * 12 * [-10.,90.] * P1TDOUT * tpion1(2) * 16 * R*4 * 12 * [0.,4000.] * P1TDOUT * epion1(2) * 17 * R*4 * 12 * [0.,100.] * P1TDOUT * epionc1(2) * 1 * R*4 * 12 * [0.,120.] * P1TDOUT2 * tmu2p1(2) * 2 * R*4 * 12 * [0.,1000.] * P1TDOUT2 * emu2p1(2) * 3 * R*4 * 12 * [0.,20.] * P1TDOUT2 * emuc2p1(2) * 4 * R*4 * 12 * [-30.,30.] * P1TDOUT2 * dt2p1 * 5 * R*4 * 9 * [0.,1000.] * P1TDOUT2 * emut2p1 * 6 * R*4 * 12 * [0.,20.] * P1TDOUT2 * emutc2p1 * 7 * R*4 * 12 * [0.,120.] * P1TDOUT2 * tmuav2p1 * 8 * R*4 * 12 * [-10.,90.] * P1TDOUT2 * tpi2p1(2) * 9 * R*4 * 12 * [0.,4000.] * P1TDOUT2 * epi2p1(2) * 10 * R*4 * 12 * [0.,100.] * P1TDOUT2 * epic2p1(2) * 1 * U*4 * 10 * [0,1023] * P1TDOUT3 * kpiflg * 2 * L*4 * 1 * * P1TDOUT3 * LPIFLG * 3 * R*4 * 16 * [0.,2000.] * P1TDOUT3 * C3PEND1(2) * 4 * R*4 * 9 * [0.,100.] * P1TDOUT3 * CMU3P1(2) * 5 * R*4 * 9 * [0.,100.] * P1TDOUT3 * CPI3P1(2) * 6 * R*4 * 12 * [-120.,120.] * P1TDOUT3 * T3P1(2) * 7 * R*4 * 12 * [0.,1000.] * P1TDOUT3 * E3P1(2) * 8 * R*4 * 12 * [0.,20.] * P1TDOUT3 * E3PC1(2) * 9 * R*4 * 7 * [-5.,20.] * P1TDOUT3 * P3PED1(2) * 10 * R*4 * 12 * [-30.,30.] * P1TDOUT3 * DT31 * 11 * R*4 * 12 * [-120.,120.] * P1TDOUT3 * T3PAV1 * 12 * R*4 * 16 * [0.,1000.] * P1TDOUT3 * PROD31 * 13 * R*4 * 16 * [0.,1.] * P1TDOUT3 * PPIEND1(2) * 14 * R*4 * 16 * [0.,1.] * P1TDOUT3 * PMUEND1(2) * 15 * R*4 * 16 * [0.,1.] * P1TDOUT3 * P3PEND1(2) * 1 * R*4 * 11 * [0.,500.] * P1UTCRS * ers * 2 * R*4 * 10 * [0.,80.] * P1UTCRS * rrs * 3 * I*4 * 6 * [-1,22] * P1UTCRS * layv4 * 4 * I*4 * 6 * [-1,25] * P1UTCRS * secv4 * 5 * R*4 * 10 * [-1.,1.] * P1UTCRS * cos3d * 6 * R*4 * 11 * [-1.,700.] * P1UTCRS * pdc * 7 * U*4 * 4 * [0,12] * P1UTCRS * ndclay * 8 * R*4 * 10 * [-80.,80.] * P1UTCRS * zf * 9 * R*4 * 10 * [0.,50.] * P1UTCRS * elast * 10 * R*4 * 10 * [0.,50.] * P1UTCRS * elast_cor * 11 * R*4 * 10 * [-50.,70.] * P1UTCRS * tk * 12 * R*4 * 10 * [-10.,100.] * P1UTCRS * tpi * 13 * I*4 * 5 * [-1,10] * P1UTCRS * ictpi * 14 * I*4 * 5 * [-1,12] * P1UTCRS * itgqualt * 15 * R*4 * 8 * [0.,100.] * P1UTCRS * etg * 16 * R*4 * 7 * [-1.,25.] * P1UTCRS * rtg * 17 * R*4 * 9 * [-7.,7.] * P1UTCRS * tgx * 18 * R*4 * 9 * [-7.,7.] * P1UTCRS * tgy * 19 * R*4 * 10 * [-20.,20.] * P1UTCRS * tgz * 20 * R*4 * 8 * [-10.,250.] * P1UTCRS * ek * 21 * R*4 * 9 * [0.,50.] * P1UTCRS * eic * 22 * R*4 * 7 * [0.,5.] * P1UTCRS * ric * 23 * R*4 * 9 * [0.,50.] * P1UTCRS * eicest * 24 * R*4 * 12 * [0.,300.] * P1UTCRS * ptot * 25 * R*4 * 12 * [0.,300.] * P1UTCRS * ptote * 26 * R*4 * 12 * [0.,100.] * P1UTCRS * rtot * 27 * R*4 * 12 * [0.,300.] * P1UTCRS * etot * 28 * R*4 * 12 * [-100.,200.] * P1UTCRS * b4strob * 29 * R*4 * 10 * [-10.,70.] * P1UTCRS * tdot2t * 30 * R*4 * 10 * [-10.,100.] * P1UTCRS * ictime * 31 * R*4 * 10 * [-10.,70.] * P1UTCRS * tds * 32 * R*4 * 8 * [-30.,30.] * P1UTCRS * rsz1d * 33 * R*4 * 8 * [-30.,30.] * P1UTCRS * rsz2d * 34 * R*4 * 8 * [-30.,30.] * P1UTCRS * rsz1d2 * 35 * R*4 * 8 * [-30.,30.] * P1UTCRS * rsz2d2 * 36 * R*4 * 9 * [-50.,50.] * P1UTCRS * zutout * 37 * R*4 * * * P1UTCRS * radius * 38 * R*4 * * * P1UTCRS * d0 * 39 * R*4 * * * P1UTCRS * phi0 * 40 * R*4 * * * P1UTCRS * tanl * 41 * U*4 * 5 * [0,24] * P1UTCRS * nhxy * 42 * U*4 * 3 * [0,6] * P1UTCRS * nhz * 43 * R*4 * 10 * [0.,50.] * P1UTCRS * chidfxy * 44 * R*4 * 10 * [0.,50.] * P1UTCRS * chidfz * 45 * R*4 * 10 * [-10.,10.] * P1UTCRS * rsxy1d * 46 * R*4 * 10 * [-10.,10.] * P1UTCRS * rsxy2d * 47 * U*4 * 4 * [0,10] * P1UTCRS * ntr_d * 1 * I*4 * * [0,10] * P1UTCRS2 * ncross * 2 * R*4 * 10 * [-10.,10.] * P1UTCRS2 * rscrsd(ncross) * 3 * R*4 * 8 * [63.,67.] * P1UTCRS2 * rsr1 * 4 * R*4 * 14 * [-3.15,3.15] * P1UTCRS2 * rsp1 * 5 * R*4 * 10 * [-60.,60.] * P1UTCRS2 * rsz1 * 6 * R*4 * 8 * [73.,77.] * P1UTCRS2 * rsr2 * 7 * R*4 * 14 * [-3.15,3.15] * P1UTCRS2 * rsp2 * 8 * R*4 * 10 * [-60.,60.] * P1UTCRS2 * rsz2 * 9 * R*4 * 12 * [45.,90.] * P1UTCRS2 * rscrsr(ncross) * 10 * R*4 * 14 * [-3.15,3.15] * P1UTCRS2 * rscrsp(ncross) * 1 * U*4 * 3 * [0,6] * P1UTCRS3 * iicout * 2 * U*4 * 3 * [0,6] * P1UTCRS3 * iicin * 3 * R*4 * 9 * [0.,50.] * P1UTCRS3 * eicout * 4 * R*4 * 9 * [0.,50.] * P1UTCRS3 * eicin * 5 * R*4 * 10 * [-20.,100.] * P1UTCRS3 * ticout * 6 * R*4 * 10 * [-20.,100.] * P1UTCRS3 * ticin * 7 * R*4 * 11 * [-50.,100.] * P1UTCRS3 * tdtic_i * 8 * R*4 * 11 * [-50.,100.] * P1UTCRS3 * tdtic_o * 9 * R*4 * 9 * [0.,20.] * P1UTCRS3 * tdaic_i * 10 * R*4 * 9 * [0.,20.] * P1UTCRS3 * tdaic_o * 11 * L*4 * 1 * * P1UTCRS3 * tdicout * 12 * L*4 * 1 * * P1UTCRS3 * tdicin * 1 * I*4 * * [0,128] * TDPLS * NRAW1 * 2 * I*4 * * [0,128] * TDPLS * NPS1 * 3 * R*4 * 7 * [-20.,20.] * TDPLS * PEDS1 * 4 * I*4 * * [0,128] * TDPLS * NP1D1 * 5 * I*4 * * [0,128] * TDPLS * NP2D1 * 6 * R*4 * 7 * [-20.,20.] * TDPLS * PEDD1 * 7 * I*4 * * [0,128] * TDPLS * NRAW2 * 8 * I*4 * * [0,128] * TDPLS * NPS2 * 9 * R*4 * 7 * [-20.,20.] * TDPLS * PEDS2 * 10 * I*4 * * [0,128] * TDPLS * NP1D2 * 11 * I*4 * * [0,128] * TDPLS * NP2D2 * 12 * R*4 * 7 * [-20.,20.] * TDPLS * PEDD2 * 13 * R*4 * 10 * [-10.,300.] * TDPLS * TDFRAW1(NRAW1) * 14 * R*4 * 10 * [-10.,300.] * TDPLS * TDFPS1(NPS1) * 15 * R*4 * 10 * [-10.,300.] * TDPLS * TDFP1D1(NP1D1) * 16 * R*4 * 10 * [-10.,300.] * TDPLS * TDFP2D1(NP2D1) * 17 * R*4 * 10 * [-10.,300.] * TDPLS * TDFRAW2(NRAW2) * 18 * R*4 * 10 * [-10.,300.] * TDPLS * TDFPS2(NPS2) * 19 * R*4 * 10 * [-10.,300.] * TDPLS * TDFP1D2(NP1D2) * 20 * R*4 * 10 * [-10.,300.] * TDPLS * TDFP2D2(NP2D2) * 1 * I*4 * * [0,128] * TDPLS3 * NP1T1 * 2 * I*4 * * [0,128] * TDPLS3 * NP2T1 * 3 * I*4 * * [0,128] * TDPLS3 * NP3T1 * 4 * I*4 * * [0,128] * TDPLS3 * NP1T2 * 5 * I*4 * * [0,128] * TDPLS3 * NP2T2 * 6 * I*4 * * [0,128] * TDPLS3 * NP3T2 * 7 * R*4 * 7 * [-20.,20.] * TDPLS3 * PEDT1 * 8 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP1T1(NP1T1) * 9 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP2T1(NP2T1) * 10 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP3T1(NP3T1) * 11 * R*4 * 7 * [-20.,20.] * TDPLS3 * PEDT2 * 12 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP1T2(NP1T2) * 13 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP2T2(NP2T2) * 14 * R*4 * 10 * [-10.,300.] * TDPLS3 * TDFP3T2(NP3T2) * 1 * R*4 * 12 * [0.,1.] * P1NEW * PR_RF * 2 * R*4 * 12 * [-10.,0.] * P1NEW * PR_RFZ1 * 3 * R*4 * 12 * [0.,1.] * P1NEW * PR_RFZ2 * 4 * R*4 * 12 * [0.,1.] * P1NEW * PR_RFZ2B * 5 * R*4 * 12 * [0.,10.] * P1NEW * LIKE * 6 * R*4 * 12 * [0.,10.] * P1NEW * LIKE2 * 7 * R*4 * 10 * [-8.,8.] * P1NEW * XIN * 8 * R*4 * 10 * [-8.,8.] * P1NEW * YIN * 9 * R*4 * 12 * [0.,5.] * P1NEW * DB4 * 10 * R*4 * 12 * [0.,5.] * P1NEW * DB4TIP * 11 * R*4 * 12 * [0.,3.] * P1NEW * DVXTIP * 12 * L*4 * 1 * * P1NEW * QB4 * 13 * R*4 * 10 * [0.,5.] * P1NEW * DVXPI * 14 * R*4 * 10 * [0.,180.] * P1NEW * KPIANG * 15 * R*4 * 10 * [0.,16.] * P1NEW * DEXTIP * 16 * U*4 * 3 * [0,7] * P1NEW * UTCHNU1 * 17 * U*4 * 3 * [0,7] * P1NEW * UTCHNU2 * 18 * U*4 * 3 * [0,7] * P1NEW * UTCHNU3 * 19 * R*4 * 12 * [-10.,0.] * P1NEW * LOGUTCQ * 20 * R*4 * 12 * [-10.,0.] * P1NEW * LOGUTCQI(6) * 1 * R*4 * 12 * [0.,300.] * RSRATE * rs_rate(10) * 1 * I*4 * * [0,25] * RDZ * rdz_np * 2 * I*4 * 3 * [-2,2] * RDZ * rdz_ok * 3 * R*4 * * * RDZ * rdz_sl * 4 * R*4 * * * RDZ * rdz_z0 * 5 * R*4 * * * RDZ * rdz_x2 * 6 * R*4 * * * RDZ * rdz_cv(3) * 7 * R*4 * 12 * [-100.,100.] * RDZ * rdz_zs(rdz_np) * 8 * R*4 * 11 * [0.,100.] * RDZ * rdz_rs(rdz_np) * 9 * R*4 * 10 * [0.,50.] * RDZ * rdz_sg(rdz_np) * 10 * R*4 * * * RDZ * rdz_us * 11 * R*4 * * * RDZ * rdz_uz * 1 * I*4 * * [0,10] * L11 * nplp * 2 * I*4 * * [0,10] * L11 * nplm * 3 * I*4 * * * L11 * tdchanp * 4 * I*4 * * * L11 * tdchanm * 5 * I*4 * * * L11 * xtimep(nplp) * 6 * R*4 * * * L11 * letp(nplp) * 7 * I*4 * * * L11 * pmaxp(nplp) * 8 * I*4 * * * L11 * psump(nplp) * 9 * I*4 * * * L11 * xtimem(nplm) * 10 * R*4 * * * L11 * letm(nplm) * 11 * I*4 * * * L11 * pmaxm(nplm) * 12 * I*4 * * * L11 * psumm(nplm) * 13 * I*4 * * * L11 * trl1_1rc * 14 * I*4 * * * L11 * tescp * 15 * I*4 * * * L11 * tescm * 16 * I*4 * * * L11 * tercp * 17 * I*4 * * * L11 * tercm * 18 * I*4 * * * L11 * flagp(nplp) * 19 * I*4 * * * L11 * flagm(nplm) * 20 * I*4 * * * L11 * fidxtp * 21 * R*4 * * * L11 * fidletp * 22 * I*4 * * * L11 * fidxtm * 23 * R*4 * * * L11 * fidletm * 24 * I*4 * * * L11 * feraup * 25 * I*4 * * * L11 * feradn * 1 * I*4 * * * TDPROMPT * prchanp * 2 * I*4 * * * TDPROMPT * prchanm * 3 * I*4 * * * TDPROMPT * prxtp * 4 * I*4 * * * TDPROMPT * prxtm * 5 * R*4 * * * TDPROMPT * prletp * 6 * R*4 * * * TDPROMPT * prletm * 7 * I*4 * * * TDPROMPT * prpmp * 8 * I*4 * * * TDPROMPT * prpmm * 9 * I*4 * * * TDPROMPT * prpsp * 10 * I*4 * * * TDPROMPT * prpsm * 11 * I*4 * * * TDPROMPT * dxtp * 12 * I*4 * * * TDPROMPT * dxtm * 13 * I*4 * * * TDPROMPT * dpsp * 14 * I*4 * * * TDPROMPT * dpsm * 15 * I*4 * * * TDPROMPT * hexscp * 16 * I*4 * * * TDPROMPT * hexscm * 17 * I*4 * * * TDPROMPT * rcp * 18 * I*4 * * * TDPROMPT * rcm * 19 * I*4 * * * TDPROMPT * trhex * 20 * I*4 * * * TDPROMPT * trsec * 21 * I*4 * * * TDPROMPT * trlay * 22 * I*4 * * * TDPROMPT * trgsc * 23 * I*4 * * * TDPROMPT * smsc * 24 * I*4 * * * TDPROMPT * smaddr * 25 * I*4 * * * TDPROMPT * prbnkp * 26 * I*4 * * * TDPROMPT * prbchp * 27 * I*4 * * * TDPROMPT * prbnkm * 28 * I*4 * * * TDPROMPT * prbchm * 29 * I*4 * * * TDPROMPT * prflagp * 30 * I*4 * * * TDPROMPT * prflagm * 31 * I*4 * * * TDPROMPT * prfxtp * 32 * I*4 * * * TDPROMPT * prfxtm * 33 * R*4 * * * TDPROMPT * prfletp * 34 * R*4 * * * TDPROMPT * prfletm * 35 * R*4 * * * TDPROMPT * prdstm * 36 * R*4 * * * TDPROMPT * prbstm * 1 * I*4 * * [0,256] * TDERROR * nobadsc * 2 * I*4 * * * TDERROR * badsc(nobadsc) * 3 * I*4 * * * TDERROR * badscidx(nobadsc) * 4 * I*4 * * [0,256] * TDERROR * nobadrc * 5 * I*4 * * * TDERROR * badrcidx(nobadrc) * 6 * I*4 * * [0,256] * TDERROR * nobadtd * 7 * I*4 * * * TDERROR * badtdidx(nobadtd) * 8 * I*4 * * [0,256] * TDERROR * nobadfd * 9 * I*4 * * * TDERROR * badfdidx(nobadfd) * 1 * R*4 * 10 * [-1.,1.] * UTCTT * cos3d1 * 2 * R*4 * * * UTCTT * radius1 * 3 * R*4 * * * UTCTT * d01 * 4 * R*4 * * * UTCTT * phi01 * 5 * R*4 * * * UTCTT * tanl1 * 6 * R*4 * 10 * [0.,50.] * UTCTT * chidfxy1 * 7 * U*4 * 5 * [0,24] * UTCTT * nhxy1 * 8 * R*4 * 9 * [-7.,7.] * UTCTT * tgx1 * 9 * R*4 * 9 * [-7.,7.] * UTCTT * tgy1 * 1 * R*4 * 10 * [0.,1.] * P2KIN * CL_EPRCOR * 2 * R*4 * 10 * [-20.,20.] * P2KIN * DELTARP * 3 * R*4 * 10 * [-20.,20.] * P2KIN * DELTARE * 4 * R*4 * 10 * [-5.,5.] * P2KIN * SIG_P * 5 * R*4 * 10 * [-5.,5.] * P2KIN * SIG_E * 6 * R*4 * 10 * [-5.,5.] * P2KIN * FDEDX * 7 * R*4 * 10 * [0.,1.] * P2KIN * CL_RSDEDX * 8 * R*4 * 10 * [0.,1.] * P2KIN * CL_RSDEDX2 * 9 * R*4 * 10 * [0.,10.] * P2KIN * CHIMAX_RSDEDX * 10 * U*4 * 5 * [0,21] * P2KIN * LAY_CHIMAX * 11 * U*4 * 4 * [0,10] * P2KIN * NPRPAT * 12 * R*4 * 12 * [-100.,100.] * P2KIN * DZUTSC14 * 13 * R*4 * 12 * [-100.,100.] * P2KIN * L14ACC * 14 * U*4 * 3 * [0,4] * P2KIN * ICODE_L14 * 15 * U*4 * 3 * [0,4] * P2KIN * ICODE_L14ACC * 1 * I*4 * * [0,100] * P2TG1 * NK_TG * 2 * R*4 * 10 * [-20.,80.] * P2TG1 * TK_TG(NK_TG) * 3 * R*4 * 10 * [0.,100.] * P2TG1 * EK_TG(NK_TG) * 4 * U*4 * 10 * [0,576] * P2TG1 * ELK_TG(NK_TG) * 5 * U*4 * 3 * [0,4] * P2TG1 * ELKP_TG(NK_TG) * 6 * U*4 * 3 * [0,4] * P2TG1 * ITQK(NK_TG) * 7 * I*4 * * [0,100] * P2TG1 * NPI_TG * 8 * R*4 * 10 * [-20.,80.] * P2TG1 * TPI_TG(NPI_TG) * 9 * R*4 * 10 * [0.,100.] * P2TG1 * EPI_TG(NPI_TG) * 10 * U*4 * 10 * [0,576] * P2TG1 * ELPI_TG(NPI_TG) * 11 * U*4 * 3 * [0,4] * P2TG1 * ELPIP_TG(NPI_TG) * 12 * U*4 * 3 * [0,4] * P2TG1 * ITQPI(NPI_TG) * 13 * I*4 * * [0,100] * P2TG1 * NPIOP_TG * 14 * R*4 * 10 * [-20.,80.] * P2TG1 * TPIOP_TG(NPIOP_TG) * 15 * R*4 * 10 * [0.,100.] * P2TG1 * EPIOP_TG(NPIOP_TG) * 16 * U*4 * 10 * [0,576] * P2TG1 * ELPIOP_TG(NPIOP_TG) * 17 * U*4 * 3 * [0,4] * P2TG1 * ELPIOPP_TG(NPIOP_TG) * 18 * U*4 * 3 * [0,4] * P2TG1 * ITQPIOP(NPIOP_TG) * 19 * R*4 * 10 * [-20.,80.] * P2TG1 * CCDTK(2,NK_TG) * 20 * R*4 * 10 * [-1.,15000.] * P2TG1 * CCDEK(2,NK_TG) * 21 * R*4 * 10 * [0.,1023.] * P2TG1 * CCDHK(2,NK_TG) * 22 * R*4 * 9 * [0.,50.] * P2TG1 * CCDRK(2,NK_TG) * 23 * L*4 * 1 * * P2TG1 * LCCDK(2,NK_TG) * 24 * R*4 * 10 * [-20.,80.] * P2TG1 * CCDTPI(NPI_TG) * 25 * R*4 * 10 * [-1.,2500.] * P2TG1 * CCDEPI(NPI_TG) * 27 * R*4 * 8 * [0.,25.] * P2TG1 * CCDRPI(NPI_TG) * 28 * L*4 * 1 * * P2TG1 * LCCDPI(NPI_TG) * 29 * R*4 * 10 * [-20.,80.] * P2TG1 * CCDTPIOP(NPIOP_TG) * 30 * R*4 * 10 * [-1.,2500.] * P2TG1 * CCDEPIOP(NPIOP_TG) * 31 * R*4 * 10 * [0.,1023.] * P2TG1 * CCDHPIOP(NPIOP_TG) * 32 * R*4 * 8 * [0.,25.] * P2TG1 * CCDRPIOP(NPIOP_TG) * 33 * L*4 * 1 * * P2TG1 * LCCDPIOP(NPIOP_TG) * 34 * I*4 * * [0,50] * P2TG1 * NEDGE_TG * 35 * R*4 * 10 * [-20.,80.] * P2TG1 * TEDGE_TG(NEDGE_TG) * 36 * R*4 * 10 * [0.,100.] * P2TG1 * EEDGE_TG(NEDGE_TG) * 37 * U*4 * 5 * [0,24] * P2TG1 * ELEDGE_TG(NEDGE_TG) * 1 * R*4 * 10 * [0.,100.] * P2TG2 * ETGVET_TG * 2 * U*4 * 5 * [0,30] * P2TG2 * NTGVET_TG * 3 * R*4 * 10 * [0.,8.] * P2TG2 * DIST_TARGF * 4 * R*4 * 10 * [0.,30.] * P2TG2 * EPIMAX_TG * 5 * R*4 * 10 * [-10.,90.] * P2TG2 * TPIMAX_TG * 6 * U*4 * 5 * [0,30] * P2TG2 * NTRIK_TG * 7 * R*4 * 10 * [-20.,20.] * P2TG2 * XTGT_TP * 8 * R*4 * 10 * [-20.,20.] * P2TG2 * YTGT_TP * 9 * R*4 * 10 * [-20.,20.] * P2TG2 * ZTGT_TP * 10 * R*4 * 10 * [0.,15.] * P2TG2 * DTGT_TP * 11 * R*4 * 10 * [0.,5.] * P2TG2 * RTDIF_TG * 12 * R*4 * 11 * [0.,20.] * P2TG2 * EPIMAXK * 13 * R*4 * 12 * [-0.5,0.5] * P2TG2 * PHIVTX * 14 * R*4 * 12 * [-10.,10.] * P2TG2 * DRPMAX * 15 * R*4 * 12 * [-10.,10.] * P2TG2 * DRPMIN * 16 * U*4 * 7 * [0,100] * P2TG2 * NKCLUST * 17 * U*4 * 7 * [0,100] * P2TG2 * NKCLUST2 * 18 * R*4 * 10 * [0.,20.] * P2TG2 * PLN_SW * 19 * R*4 * 10 * [0.,20.] * P2TG2 * PLNV_SW * 20 * R*4 * 10 * [-8.,8.] * P2TG2 * X_B4SW * 21 * R*4 * 10 * [-8.,8.] * P2TG2 * Y_B4SW * 22 * U*4 * 2 * [0,2] * P2TG2 * IFAIL_KIC * 23 * R*4 * 10 * [0.,10.] * P2TG2 * DTK * 24 * R*4 * 10 * [0.,10.] * P2TG2 * DTPI * 1 * I*4 * * [0,15] * P2TG3 * NK_TG_S * 2 * U*4 * 22 * [0,4194303] * P2TG3 * CCDPF(2,NK_TG_S) * 3 * U*4 * 7 * [0,127] * P2TG3 * CCDBIN(2,NK_TG_S) * 4 * R*4 * 10 * [60.,80.] * P2TG3 * TCALKL(NK_TG_S) * 5 * R*4 * 10 * [45.,65.] * P2TG3 * TCALKH(NK_TG_S) * 6 * I*4 * * [0,127] * P2TG3 * NBK1L * 7 * I*4 * * [0,127] * P2TG3 * NBK2L * 8 * I*4 * * [0,127] * P2TG3 * NBK3L * 9 * I*4 * * [0,127] * P2TG3 * NBK4L * 10 * I*4 * * [0,127] * P2TG3 * NBK5L * 11 * I*4 * * [0,127] * P2TG3 * NBK6L * 12 * I*4 * * [0,127] * P2TG3 * NBK7L * 13 * I*4 * * [0,127] * P2TG3 * NBK8L * 14 * I*4 * * [0,127] * P2TG3 * NBK9L * 15 * I*4 * * [0,127] * P2TG3 * NBK10L * 16 * I*4 * * [0,127] * P2TG3 * NBK11L * 17 * I*4 * * [0,127] * P2TG3 * NBK12L * 18 * I*4 * * [0,127] * P2TG3 * NBK13L * 19 * I*4 * * [0,127] * P2TG3 * NBK14L * 20 * I*4 * * [0,127] * P2TG3 * NBK15L * 21 * I*4 * 11 * [-9,1000] * P2TG3 * CCD1L(NBK1L) * 22 * I*4 * 11 * [-9,1000] * P2TG3 * CCD2L(NBK2L) * 23 * I*4 * 11 * [-9,1000] * P2TG3 * CCD3L(NBK3L) * 24 * I*4 * 11 * [-9,1000] * P2TG3 * CCD4L(NBK4L) * 25 * I*4 * 11 * [-9,1000] * P2TG3 * CCD5L(NBK5L) * 26 * I*4 * 11 * [-9,1000] * P2TG3 * CCD6L(NBK6L) * 27 * I*4 * 11 * [-9,1000] * P2TG3 * CCD7L(NBK7L) * 28 * I*4 * 11 * [-9,1000] * P2TG3 * CCD8L(NBK8L) * 29 * I*4 * 11 * [-9,1000] * P2TG3 * CCD9L(NBK9L) * 30 * I*4 * 11 * [-9,1000] * P2TG3 * CCD10L(NBK10L) * 31 * I*4 * 11 * [-9,1000] * P2TG3 * CCD11L(NBK11L) * 32 * I*4 * 11 * [-9,1000] * P2TG3 * CCD12L(NBK12L) * 33 * I*4 * 11 * [-9,1000] * P2TG3 * CCD13L(NBK13L) * 34 * I*4 * 11 * [-9,1000] * P2TG3 * CCD14L(NBK14L) * 35 * I*4 * 11 * [-9,1000] * P2TG3 * CCD15L(NBK15L) * 1 * I*4 * * [0,127] * P2TG4 * NBK1H * 2 * I*4 * * [0,127] * P2TG4 * NBK2H * 3 * I*4 * * [0,127] * P2TG4 * NBK3H * 4 * I*4 * * [0,127] * P2TG4 * NBK4H * 5 * I*4 * * [0,127] * P2TG4 * NBK5H * 6 * I*4 * * [0,127] * P2TG4 * NBK6H * 7 * I*4 * * [0,127] * P2TG4 * NBK7H * 8 * I*4 * * [0,127] * P2TG4 * NBK8H * 9 * I*4 * * [0,127] * P2TG4 * NBK9H * 10 * I*4 * * [0,127] * P2TG4 * NBK10H * 11 * I*4 * * [0,127] * P2TG4 * NBK11H * 12 * I*4 * * [0,127] * P2TG4 * NBK12H * 13 * I*4 * * [0,127] * P2TG4 * NBK13H * 14 * I*4 * * [0,127] * P2TG4 * NBK14H * 15 * I*4 * * [0,127] * P2TG4 * NBK15H * 16 * I*4 * 11 * [-9,1000] * P2TG4 * CCD1H(NBK1H) * 17 * I*4 * 11 * [-9,1000] * P2TG4 * CCD2H(NBK2H) * 18 * I*4 * 11 * [-9,1000] * P2TG4 * CCD3H(NBK3H) * 19 * I*4 * 11 * [-9,1000] * P2TG4 * CCD4H(NBK4H) * 20 * I*4 * 11 * [-9,1000] * P2TG4 * CCD5H(NBK5H) * 21 * I*4 * 11 * [-9,1000] * P2TG4 * CCD6H(NBK6H) * 22 * I*4 * 11 * [-9,1000] * P2TG4 * CCD7H(NBK7H) * 23 * I*4 * 11 * [-9,1000] * P2TG4 * CCD8H(NBK8H) * 24 * I*4 * 11 * [-9,1000] * P2TG4 * CCD9H(NBK9H) * 25 * I*4 * 11 * [-9,1000] * P2TG4 * CCD10H(NBK10H) * 26 * I*4 * 11 * [-9,1000] * P2TG4 * CCD11H(NBK11H) * 27 * I*4 * 11 * [-9,1000] * P2TG4 * CCD12H(NBK12H) * 28 * I*4 * 11 * [-9,1000] * P2TG4 * CCD13H(NBK13H) * 29 * I*4 * 11 * [-9,1000] * P2TG4 * CCD14H(NBK14H) * 30 * I*4 * 11 * [-9,1000] * P2TG4 * CCD15H(NBK15H) * 1 * I*4 * * [0,15] * P2TG7 * nfitfib * 2 * U*4 * 4 * [0,15] * P2TG7 * nfitdoub * 3 * U*4 * 10 * [0,600] * P2TG7 * nfitelm(nfitfib) * 4 * U*4 * 4 * [0,15] * P2TG7 * crind(nfitfib) * 5 * R*4 * 15 * [0.,150.] * P2TG7 * adcenrg(nfitfib) * 6 * R*4 * 15 * [-10.,50.] * P2TG7 * singltim(nfitfib) * 7 * R*4 * 20 * [0.,20000.] * P2TG7 * singlamp(nfitfib) * 8 * R*4 * 12 * [0.,30.] * P2TG7 * singlchi2(nfitfib) * 9 * R*4 * 14 * [0.,1.] * P2TG7 * singlprob(nfitfib) * 10 * U*4 * 7 * [0,120] * P2TG7 * singldof(nfitfib) * 11 * R*4 * 15 * [-10.,50.] * P2TG7 * doubltimk(nfitfib) * 12 * R*4 * 20 * [0.,20000.] * P2TG7 * doublampk(nfitfib) * 13 * R*4 * 15 * [-5.,60.] * P2TG7 * doubltimp(nfitfib) * 14 * R*4 * 24 * [-1000.1,100 * P2TG7 * doublampp(nfitfib) * 15 * R*4 * 15 * [-10.,10.] * P2TG7 * errtimk(nfitfib) * 16 * R*4 * 20 * [0.,20000.] * P2TG7 * errampk(nfitfib) * 17 * R*4 * 15 * [-5.,60.] * P2TG7 * errtimp(nfitfib) * 18 * R*4 * 24 * [-1000.1,100 * P2TG7 * errampp(nfitfib) * 19 * R*4 * 12 * [0.,30.] * P2TG7 * doublchi2(nfitfib) * 20 * R*4 * 14 * [0.,1.] * P2TG7 * doublprob(nfitfib) * 21 * U*4 * 7 * [0,120] * P2TG7 * doubldof(nfitfib) * 22 * U*4 * 7 * [0,120] * P2TG7 * nonzbins(nfitfib) * 23 * I*4 * 4 * [-2,2] * P2TG7 * doublflag(nfitfib) * 1 * I*4 * * [0,15] * P2TG8 * lnfitfib * 2 * U*4 * 4 * [0,15] * P2TG8 * lnfitdoub * 3 * U*4 * 10 * [0,600] * P2TG8 * lnfitelm(lnfitfib) * 4 * U*4 * 4 * [0,15] * P2TG8 * lcrind(lnfitfib) * 5 * U*4 * 2 * [0,2] * P2TG8 * lmuxflag(lnfitfib) * 6 * R*4 * 15 * [0.,150.] * P2TG8 * ladcenrg(lnfitfib) * 7 * R*4 * 15 * [-10.,50.] * P2TG8 * lsingltim(lnfitfib) * 8 * R*4 * 20 * [0.,20000.] * P2TG8 * lsinglamp(lnfitfib) * 9 * R*4 * 12 * [0.,30.] * P2TG8 * lsinglchi2(lnfitfib) * 10 * R*4 * 14 * [0.,1.] * P2TG8 * lsinglprob(lnfitfib) * 11 * U*4 * 7 * [0,120] * P2TG8 * lsingldof(lnfitfib) * 12 * R*4 * 15 * [-10.,50.] * P2TG8 * ldoubltimk(lnfitfib) * 13 * R*4 * 20 * [0.,20000.] * P2TG8 * ldoublampk(lnfitfib) * 14 * R*4 * 15 * [-5.,60.] * P2TG8 * ldoubltimp(lnfitfib) * 15 * R*4 * 24 * [-1000.1,100 * P2TG8 * ldoublampp(lnfitfib) * 16 * R*4 * 15 * [-10.,10.] * P2TG8 * lerrtimk(lnfitfib) * 17 * R*4 * 20 * [0.,20000.] * P2TG8 * lerrampk(lnfitfib) * 18 * R*4 * 15 * [-5.,60.] * P2TG8 * lerrtimp(lnfitfib) * 19 * R*4 * 24 * [-1000.1,100 * P2TG8 * lerrampp(lnfitfib) * 20 * R*4 * 12 * [0.,30.] * P2TG8 * ldoublchi2(lnfitfib) * 21 * R*4 * 14 * [0.,1.] * P2TG8 * ldoublprob(lnfitfib) * 22 * U*4 * 7 * [0,120] * P2TG8 * ldoubldof(lnfitfib) * 23 * U*4 * 7 * [0,120] * P2TG8 * lnonzbins(lnfitfib) * 24 * I*4 * 4 * [-2,2] * P2TG8 * ldoublflag(lnfitfib) * 1 * I*4 * * [0,50] * P2TD * NELVET * 2 * U*4 * 3 * [0,5] * P2TD * ISEV(NELVET) * 3 * U*4 * 5 * [0,31] * P2TD * ISTEV5 * 4 * U*4 * 5 * [0,31] * P2TD * ISTEV5M1 * 5 * R*4 * 20 * [-50.,50.] * P2TD * T1MT2 * 6 * R*4 * 13 * [-1.,20000.] * P2TD * EELEC1 * 7 * R*4 * 13 * [-1.,20000.] * P2TD * EELEC2 * 8 * R*4 * 12 * [-1.,150.] * P2TD * EELEC2C * 9 * R*4 * 16 * [0.,11000.] * P2TD * TELEC * 10 * R*4 * 12 * [-50.,50.] * P2TD * DTELEC * 11 * R*4 * 10 * [0.,1.] * P2TD * PROBTD * 12 * R*4 * 10 * [0.,1.] * P2TD * PROBTDN * 13 * U*4 * 4 * [0,10] * P2TD * IFAIL_TDFL * 14 * I*4 * * [0,25] * P2TD * NHEXCT * 15 * U*4 * 4 * [0,12] * P2TD * ICODE_TDFL(NHEXCT) * 16 * R*4 * 10 * [0.,1000.] * P2TD * EMUT_TDFL(NHEXCT) * 17 * R*4 * 10 * [0.,20.] * P2TD * EMUTC_TDFL(NHEXCT) * 18 * R*4 * 10 * [0.,120.] * P2TD * TMUAV_TDFL(NHEXCT) * 19 * R*4 * 10 * [-30.,30.] * P2TD * DT_TDFL(NHEXCT) * 20 * R*4 * 10 * [-30.,30.] * P2TD * DTMU_TDFL(NHEXCT) * 21 * R*4 * 12 * [0.,2000.] * P2TD * CMUEND_TDFL(2,NHEXCT) * 22 * R*4 * 12 * [0.,2000.] * P2TD * CPIEND_TDFL(2,NHEXCT) * 23 * R*4 * 10 * [0.,100.] * P2TD * CMUPI_TDFL(2,NHEXCT) * 24 * R*4 * 10 * [0.,1000.] * P2TD * PROD_TDFL(NHEXCT) * 25 * U*4 * 4 * [0,10] * P2TD * IFAIL_TDFL2P * 26 * I*4 * * [0,25] * P2TD * NHEXCT2P * 27 * U*4 * 4 * [0,12] * P2TD * ICODE_TDFL2P(NHEXCT2P) * 28 * R*4 * 10 * [0.,1000.] * P2TD * EMUT_TDFL2P(NHEXCT2P) * 29 * R*4 * 10 * [0.,20.] * P2TD * EMUTC_TDFL2P(NHEXCT2P) * 30 * R*4 * 10 * [0.,120.] * P2TD * TMUAV_TDFL2P(NHEXCT2P) * 31 * R*4 * 10 * [-30.,30.] * P2TD * DT_TDFL2P(NHEXCT2P) * 32 * R*4 * 10 * [-30.,30.] * P2TD * DTMU_TDFL2P(NHEXCT2P) * 33 * R*4 * 12 * [0.,2000.] * P2TD * CMUEND_TDFL2P(2,NHEXCT2P) * 34 * R*4 * 12 * [0.,2000.] * P2TD * CPIEND_TDFL2P(2,NHEXCT2P) * 35 * R*4 * 10 * [0.,100.] * P2TD * CMUPI_TDFL2P(2,NHEXCT2P) * 36 * R*4 * 10 * [0.,1000.] * P2TD * PROD_TDFL2P(NHEXCT2P) * 37 * U*4 * 3 * [0,4] * P2TD * NHIT_STHEX * 38 * R*4 * 12 * [0.,200.] * P2TD * ESUM_STHEX * 39 * R*4 * 10 * [0.,50.] * P2TD * EMAX_STHEX * 40 * R*4 * 12 * [0.,200.] * P2TD * ESTHEX(4) * 41 * I*4 * * [0,288] * P2TD * NNOFID * 42 * U*4 * 9 * [0,288] * P2TD * CHNOFID(NNOFID) * 43 * R*4 * 12 * [-10000.,100 * P2TD * TIME_FIDX(288) * 44 * U*4 * 6 * [0,50] * P2TD * IFID_CODEX(288) * 1 * I*4 * * [0,255] * P2PV1 * NPVRD * 2 * U*4 * 9 * [0,504] * P2PV1 * ELEMPVRD(NPVRD) * 3 * R*4 * 10 * [0.,100.] * P2PV1 * EPVRD(NPVRD) * 4 * R*4 * 10 * [0.,100.] * P2PV1 * EPVRD1(NPVRD) * 5 * R*4 * 10 * [0.,100.] * P2PV1 * EPVRD2(NPVRD) * 6 * R*4 * 12 * [-200.,200.] * P2PV1 * EZPVRD(NPVRD) * 7 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRD(NPVRD) * 8 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRD1(NPVRD) * 9 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRD2(NPVRD) * 10 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRDTD(NPVRD) * 11 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRDTD1(NPVRD) * 12 * R*4 * 11 * [-50.,120.] * P2PV1 * TPVRDTD2(NPVRD) * 13 * R*4 * 10 * [0.,100.] * P2PV1 * APVRDTD(NPVRD) * 14 * R*4 * 10 * [0.,100.] * P2PV1 * HPVRDTD(NPVRD) * 15 * R*4 * 10 * [0.,100.] * P2PV1 * APVRDTD1(NPVRD) * 16 * R*4 * 10 * [0.,100.] * P2PV1 * HPVRDTD1(NPVRD) * 17 * R*4 * 10 * [0.,100.] * P2PV1 * APVRDTD2(NPVRD) * 18 * R*4 * 10 * [0.,100.] * P2PV1 * HPVRDTD2(NPVRD) * 19 * L*4 * 1 * * P2PV1 * LTRKPVRD(NPVRD) * 1 * I*4 * * [0,50] * P2PV2 * NPVBV * 2 * R*4 * 12 * [-120.,120.] * P2PV2 * TPVBV(NPVBV) * 3 * R*4 * 10 * [0.,100.] * P2PV2 * EPVBV(NPVBV) * 4 * U*4 * 8 * [0,200] * P2PV2 * ELEMPVBV(NPVBV) * 5 * R*4 * 10 * [0.,200.] * P2PV2 * EPVBVPR * 6 * R*4 * 9 * [-20.,20.] * P2PV2 * TZPVBV(NPVBV) * 7 * R*4 * 12 * [-200.,200.] * P2PV2 * EZPVBV(NPVBV) * 8 * I*4 * * [0,50] * P2PV2 * NPVBL * 9 * R*4 * 11 * [-120.,120.] * P2PV2 * TPVBL(NPVBL) * 10 * R*4 * 10 * [0.,100.] * P2PV2 * EPVBL(NPVBL) * 11 * U*4 * 6 * [1,48] * P2PV2 * ELEMPVBL(NPVBL) * 12 * R*4 * 10 * [0.,200.] * P2PV2 * EPVBLPR * 13 * R*4 * 9 * [-20.,20.] * P2PV2 * TZPVBL(NPVBL) * 14 * R*4 * 12 * [-200.,200.] * P2PV2 * EZPVBL(NPVBL) * 15 * I*4 * * [0,80] * P2PV2 * NPVEC * 16 * R*4 * 11 * [-20.,120.] * P2PV2 * TPVEC(NPVEC) * 17 * R*4 * 10 * [0.,100.] * P2PV2 * EPVEC(NPVEC) * 18 * R*4 * 9 * [5.,510.] * P2PV2 * HPVEC(NPVEC) * 19 * R*4 * 8 * [0.,25.] * P2PV2 * RPVEC(NPVEC) * 20 * U*4 * 8 * [0,220] * P2PV2 * ELEMPVEC(NPVEC) * 21 * R*4 * 10 * [0.,250.] * P2PV2 * EPVECPR * 22 * R*4 * 10 * [0.,250.] * P2PV2 * EPVEUPR * 23 * L*4 * 1 * * P2PV2 * FPVECHI(NPVEC) * 24 * L*4 * 1 * * P2PV2 * FPVECT0(NPVEC) * 25 * L*4 * 1 * * P2PV2 * FPVECSTR(NPVEC) * 26 * L*4 * 1 * * P2PV2 * FPVEC2ND(NPVEC) * 27 * L*4 * 1 * * P2PV2 * FPVECSFT(NPVEC) * 28 * L*4 * 1 * * P2PV2 * FPVECDNP(NPVEC) * 29 * L*4 * 1 * * P2PV2 * FPVECSTRD(NPVEC) * 30 * R*4 * 10 * [0.,250.] * P2PV2 * EPVECGT * 31 * R*4 * 10 * [0.,250.] * P2PV2 * EPVEUGT * 32 * R*4 * 10 * [0.,100.] * P2PV2 * EPVECFERA(NPVEC) * 1 * I*4 * * [0,40] * P2PV3 * NPVIC * 2 * R*4 * 12 * [-120.,20.] * P2PV3 * TPVIC(NPVIC) * 3 * R*4 * 9 * [0.,50.] * P2PV3 * EPVIC(NPVIC) * 4 * U*4 * 4 * [0,13] * P2PV3 * ELEMPVIC(NPVIC) * 5 * R*4 * 8 * [0.,25.] * P2PV3 * EPVICPR * 6 * R*4 * 8 * [0.,25.] * P2PV3 * EPVVCPR * 7 * I*4 * * [0,20] * P2PV3 * NPVCO * 8 * R*4 * 9 * [-20.,20.] * P2PV3 * TPVCO(NPVCO) * 9 * R*4 * 10 * [0.,100.] * P2PV3 * EPVCO(NPVCO) * 10 * U*4 * 5 * [1,24] * P2PV3 * ELEMPVCO(NPVCO) * 11 * R*4 * 10 * [0.,100.] * P2PV3 * EPVCOPR * 12 * I*4 * * [0,20] * P2PV3 * NPVCM * 13 * R*4 * 9 * [-20.,20.] * P2PV3 * TPVCM(NPVCM) * 14 * R*4 * 10 * [0.,100.] * P2PV3 * EPVCM(NPVCM) * 15 * U*4 * 3 * [1,6] * P2PV3 * ELEMPVCM(NPVCM) * 16 * R*4 * 10 * [0.,100.] * P2PV3 * EPVCMPR * 17 * I*4 * * [0,100] * P2PV3 * NPVTG * 18 * R*4 * 8 * [-20.,20.] * P2PV3 * TPVTG(NPVTG) * 19 * R*4 * 11 * [0.,200.] * P2PV3 * EPVTG(NPVTG) * 20 * U*4 * 10 * [0,576] * P2PV3 * ELEMPVTG(NPVTG) * 21 * U*4 * 3 * [0,4] * P2PV3 * ELEMPPVTG(NPVTG) * 22 * U*4 * 3 * [0,4] * P2PV3 * ITQG(NPVTG) * 23 * R*4 * 10 * [0.,250.] * P2PV3 * EPVTGPR * 24 * R*4 * 10 * [-20.,120.] * P2PV3 * CCDTPV(NPVTG) * 25 * R*4 * 10 * [-1.,100.] * P2PV3 * CCDEPV(NPVTG) * 26 * R*4 * 9 * [0.,511.] * P2PV3 * CCDHPV(NPVTG) * 27 * R*4 * 8 * [0.,25.] * P2PV3 * CCDRPV(NPVTG) * 28 * L*4 * 1 * * P2PV3 * LCCDPV(NPVTG) * 29 * I*4 * * [0,32] * P2PV3 * NPVBS * 30 * R*4 * 12 * [-200.,200.] * P2PV3 * TPVBS(NPVBS) * 31 * R*4 * 9 * [5.,510.] * P2PV3 * HPVBS(NPVBS) * 32 * U*4 * 6 * [0,32] * P2PV3 * ELEMPVBS(NPVBS) * 33 * R*4 * 12 * [-200.,200.] * P2PV3 * TPVBSTD * 34 * L*4 * 1 * * P2PV3 * FPVBSHI(NPVBS) * 35 * L*4 * 1 * * P2PV3 * FPVBST0(NPVBS) * 36 * L*4 * 1 * * P2PV3 * FPVBSSTR(NPVBS) * 37 * L*4 * 1 * * P2PV3 * FPVBSSFT(NPVBS) * 38 * L*4 * 1 * * P2PV3 * FPVBSNOTD * 1 * I*4 * * [0,100] * P2PV6 * NSABTBV * 2 * I*4 * * [0,100] * P2PV6 * NSASTBV * 3 * I*4 * * [0,100] * P2PV6 * NSANTBV * 4 * I*4 * * [0,100] * P2PV6 * NNABTBV * 5 * I*4 * * [0,100] * P2PV6 * NBASTBV * 6 * R*4 * 9 * [0.,80.] * P2PV6 * ESABTBV(NSABTBV) * 7 * R*4 * 9 * [0.,80.] * P2PV6 * ESASTBV(NSASTBV) * 8 * R*4 * 9 * [0.,80.] * P2PV6 * ESANTBV(NSANTBV) * 9 * R*4 * 9 * [0.,80.] * P2PV6 * EBASTBV(NBASTBV) * 10 * R*4 * 10 * [-90.,150.] * P2PV6 * TSABTBV(NSABTBV) * 11 * R*4 * 10 * [-90.,150.] * P2PV6 * TSASTBV(NSASTBV) * 12 * R*4 * 10 * [-90.,150.] * P2PV6 * TNABTBV(NNABTBV) * 13 * R*4 * 10 * [-90.,150.] * P2PV6 * TBASTBV(NBASTBV) * 14 * R*4 * 9 * [0.,80.] * P2PV6 * SSABTBV * 15 * R*4 * 9 * [0.,80.] * P2PV6 * SSASTBV * 16 * R*4 * 9 * [0.,80.] * P2PV6 * SBASTBV * 17 * U*4 * 9 * [0,384] * P2PV6 * ELSABTBV(NSABTBV) * 18 * U*4 * 9 * [0,384] * P2PV6 * ELSASTBV(NSASTBV) * 19 * U*4 * 9 * [0,384] * P2PV6 * ELSANTBV(NSANTBV) * 20 * U*4 * 8 * [0,192] * P2PV6 * ELNABTBV(NNABTBV) * 21 * U*4 * 3 * [0,4] * P2PV3 * ELEMPPVTG(NPVTG) * 22 * U*4 * 3 * [0,4] * P2PV3 * ITQG(NPVTG) * 23 * R*4 * 10 * [0.,250.] * P2PV3 * EPVTGPR * 24 * R*4 * 10 * [-20.,120.] * P2PV3 * CCDTPV(NPVTG) * 25 * R*4 * 10 * [-1.,100.] * P2PV3 * CCDEPV(NPVTG) * 26 * R*4 * 9 * [0.,511.] * P2PV3 * CCDHPV(NPVTG) * 27 * R*4 * 8 * [0.,25.] * P2PV3 * CCDRPV(NPVTG) * 28 * L*4 * 1 * * P2PV3 * LCCDPV(NPVTG) * 29 * I*4 * * [0,32] * P2PV3 * NPVBS * 30 * R*4 * 12 * [-200.,200.] * P2PV3 * TPVBS(NPVBS) * 31 * R*4 * 9 * [5.,510.] * P2PV3 * HPVBS(NPVBS) * 32 * U*4 * 6 * [0,32] * P2PV3 * ELEMPVBS(NPVBS) * 33 * R*4 * 12 * [-200.,200.] * P2PV3 * TPVBSTD * 34 * L*4 * 1 * * P2PV3 * FPVBSHI(NPVBS) * 35 * L*4 * 1 * * P2PV3 * FPVBST0(NPVBS) * 36 * L*4 * 1 * * P2PV3 * FPVBSSTR(NPVBS) * 37 * L*4 * 1 * * P2PV3 * FPVBSSFT(NPVBS) * 38 * L*4 * 1 * * P2PV3 * FPVBSNOTD * 1 * I*4 * * [0,100] * P2PV6 * NSABTBV * 2 * I*4 * * [0,100] * P2PV6 * NSASTBV * 3 * I*4 * * [0,100] * P2PV6 * NSANTBV * 4 * I*4 * * [0,100] * P2PV6 * NNABTBV * 5 * I*4 * * [0,100] * P2PV6 * NBASTBV * 6 * R*4 * 9 * [0.,80.] * P2PV6 * ESABTBV(NSABTBV) * 7 * R*4 * 9 * [0.,80.] * P2PV6 * ESASTBV(NSASTBV) * 8 * R*4 * 9 * [0.,80.] * P2PV6 * ESANTBV(NSANTBV) * 9 * R*4 * 9 * [0.,80.] * P2PV6 * EBASTBV(NBASTBV) * 10 * R*4 * 10 * [-90.,150.] * P2PV6 * TSABTBV(NSABTBV) * 11 * R*4 * 10 * [-90.,150.] * P2PV6 * TSASTBV(NSASTBV) * 12 * R*4 * 10 * [-90.,150.] * P2PV6 * TNABTBV(NNABTBV) * 13 * R*4 * 10 * [-90.,150.] * P2PV6 * TBASTBV(NBASTBV) * 14 * R*4 * 9 * [0.,80.] * P2PV6 * SSABTBV * 15 * R*4 * 9 * [0.,80.] * P2PV6 * SSASTBV * 16 * R*4 * 9 * [0.,80.] * P2PV6 * SBASTBV * 17 * U*4 * 9 * [0,384] * P2PV6 * ELSABTBV(NSABTBV) * 18 * U*4 * 9 * [0,384] * P2PV6 * ELSASTBV(NSASTBV) * 19 * U*4 * 9 * [0,384] * P2PV6 * ELSANTBV(NSANTBV) * 20 * U*4 * 8 * [0,192] * P2PV6 * ELNABTBV(NNABTBV) * 21 * U*4 * 9 * [0,384] * P2PV6 * ELBASTBV(NBASTBV) * 1 * I*4 * * [0,143] * P2PV7 * NISTAT7 * 2 * U*4 * 8 * [1,216] * P2PV7 * MODISTAT7(NISTAT7) * 1 * I*4 * * [0,100] * P2PV8 * NSABTBL * 2 * I*4 * * [0,100] * P2PV8 * NSASTBL * 3 * I*4 * * [0,100] * P2PV8 * NSANTBL * 4 * I*4 * * [0,100] * P2PV8 * NNABTBL * 5 * I*4 * * [0,100] * P2PV8 * NBASTBL * 6 * R*4 * 9 * [0.,80.] * P2PV8 * ESABTBL(NSABTBL) * 7 * R*4 * 9 * [0.,80.] * P2PV8 * ESASTBL(NSASTBL) * 8 * R*4 * 9 * [0.,80.] * P2PV8 * ESANTBL(NSANTBL) * 9 * R*4 * 9 * [0.,80.] * P2PV8 * EBASTBL(NBASTBL) * 10 * R*4 * 10 * [-90.,150.] * P2PV8 * TSABTBL(NSABTBL) * 11 * R*4 * 10 * [-90.,150.] * P2PV8 * TSASTBL(NSASTBL) * 12 * R*4 * 10 * [-90.,150.] * P2PV8 * TNABTBL(NNABTBL) * 13 * R*4 * 10 * [-90.,150.] * P2PV8 * TBASTBL(NBASTBL) * 14 * R*4 * 9 * [0.,80.] * P2PV8 * SSABTBL * 15 * R*4 * 9 * [0.,80.] * P2PV8 * SSASTBL * 16 * R*4 * 9 * [0.,80.] * P2PV8 * SBASTBL * 17 * U*4 * 9 * [0,384] * P2PV8 * ELSABTBL(NSABTBL) * 18 * U*4 * 9 * [0,384] * P2PV8 * ELSASTBL(NSASTBL) * 19 * U*4 * 9 * [0,384] * P2PV8 * ELSANTBL(NSANTBL) * 20 * U*4 * 8 * [0,192] * P2PV8 * ELNABTBL(NNABTBL) * 21 * U*4 * 9 * [0,384] * P2PV8 * ELBASTBL(NBASTBL) * 1 * I*4 * * [0,20] * P2PV9 * NPVUP * 2 * R*4 * 12 * [-100.,100.] * P2PV9 * TPVUP(NPVUP) * 3 * R*4 * 10 * [0.,100.] * P2PV9 * EPVUP(NPVUP) * 4 * U*4 * 2 * [1,2] * P2PV9 * ELEMPVUP(NPVUP) * 5 * R*4 * 8 * [0.,100.] * P2PV9 * EPVUPPR(NPVUP) * 6 * I*4 * * [0,40] * P2PV9 * NPVDP * 7 * R*4 * 12 * [-100.,100.] * P2PV9 * TPVDP(NPVDP) * 8 * R*4 * 10 * [0.,100.] * P2PV9 * EPVDP(NPVDP) * 9 * U*4 * 3 * [1,4] * P2PV9 * ELEMPVDP(NPVDP) * 10 * R*4 * 8 * [0.,100.] * P2PV9 * EPVDPPR(NPVDP) * 11 * I*4 * * [0,20] * P2PV9 * NPVRV * 12 * R*4 * 12 * [-100.,100.] * P2PV9 * TPVRV(NPVRV) * 13 * R*4 * 10 * [0.,100.] * P2PV9 * EPVRV(NPVRV) * 14 * U*4 * 2 * [1,2] * P2PV9 * ELEMPVRV(NPVRV) * 15 * R*4 * 8 * [0.,100.] * P2PV9 * EPVRVPR(NPVRV) * 16 * I*4 * * [0,120] * P2PV9 * NPVAD * 17 * R*4 * 12 * [-100.,100.] * P2PV9 * TPVAD(NPVAD) * 18 * R*4 * 10 * [0.,100.] * P2PV9 * EPVAD(NPVAD) * 19 * U*4 * 4 * [1,12] * P2PV9 * ELEMPVAD(NPVAD) * 20 * R*4 * 8 * [0.,100.] * P2PV9 * EPVADPR(NPVAD) * 1 * R*4 * 12 * [-30.,70.] * P2BM1 * CKTBM * 2 * R*4 * 12 * [-30.,30.] * P2BM1 * CKTRS * 3 * R*4 * 12 * [-30.,30.] * P2BM1 * CKTBM2 * 4 * R*4 * 12 * [-30.,30.] * P2BM1 * CKTRS2 * 5 * R*4 * 12 * [-30.,70.] * P2BM1 * CPITBM * 6 * R*4 * 12 * [-30.,30.] * P2BM1 * CPITRS * 7 * R*4 * 12 * [-30.,30.] * P2BM1 * CPITBM2 * 8 * R*4 * 12 * [-30.,30.] * P2BM1 * CPITRS2 * 9 * U*4 * 4 * [0,15] * P2BM1 * CKNBM * 10 * U*4 * 4 * [0,15] * P2BM1 * CKNRS * 11 * U*4 * 4 * [0,15] * P2BM1 * CPINBM * 12 * U*4 * 4 * [0,15] * P2BM1 * CPINRS * 1 * R*4 * 10 * [0.,8.] * P2BM2 * B4ABM * 2 * R*4 * 12 * [-30.,70.] * P2BM2 * B4TBM * 3 * R*4 * 10 * [0.,8.] * P2BM2 * B4ARS * 4 * R*4 * 12 * [-30.,30.] * P2BM2 * B4TRS * 5 * R*4 * 12 * [-50.,50.] * P2BM2 * B4DTBM * 6 * R*4 * 12 * [-50.,50.] * P2BM2 * PVTBM(4) * 7 * R*4 * 12 * [-50.,50.] * P2BM2 * PVTRS(4) * 8 * R*4 * 12 * [-50.,50.] * P2BM2 * B0TBM * 9 * R*4 * 12 * [-50.,50.] * P2BM2 * B0TRS * 1 * R*4 * 12 * [-100.,100.] * P2BM3 * BW1TBM * 2 * R*4 * 12 * [-100.,100.] * P2BM3 * BW2TBM * 3 * R*4 * 10 * [-30.,30.] * P2BM3 * BW1TRS * 4 * R*4 * 10 * [-30.,30.] * P2BM3 * BW2TRS * 5 * R*4 * 10 * [-30.,30.] * P2BM3 * BW1HRS * 6 * R*4 * 10 * [-30.,30.] * P2BM3 * BW2HRS * 7 * R*4 * 10 * [-30.,30.] * P2BM3 * B4HRS * 8 * R*4 * 10 * [0.,8.] * P2BM3 * B4ERS * 1 * U*4 * 2 * [0,3] * P2BM4 * IBSQUALT * 2 * U*4 * 5 * [0,17] * P2BM4 * IB4KFIN(2) * 3 * R*4 * 12 * [-100.,100.] * P2BM4 * B4STR * 4 * R*4 * 12 * [-100.,100.] * P2BM4 * B4NEARRS * 5 * R*4 * 12 * [-100.,100.] * P2BM4 * B4NEAR0 * 6 * R*4 * 12 * [-100.,100.] * P2BM4 * B4UVSTR(2) * 1 * U*4 * 2 * [0,3] * P2BM5 * B4NPBM * 2 * U*4 * 3 * [0,5] * P2BM5 * B4NHBM * 3 * U*4 * 2 * [0,3] * P2BM5 * B4NPRS * 4 * U*4 * 3 * [0,5] * P2BM5 * B4NHRS * 5 * R*4 * 10 * [0.,8.] * P2BM5 * B4ABM2 * 6 * R*4 * 10 * [0.,8.] * P2BM5 * B4ARS2 * 7 * R*4 * 12 * [-30.,70.] * P2BM5 * B4TBM2 * 8 * R*4 * 10 * [-30.,30.] * P2BM5 * B4TRS2 * 9 * U*4 * 2 * [0,3] * P2BM5 * bw1npbm * 10 * U*4 * 2 * [0,3] * P2BM5 * bw2npbm * 11 * U*4 * 2 * [0,3] * P2BM5 * bw1nprs * 12 * U*4 * 2 * [0,3] * P2BM5 * bw2nprs * 13 * R*4 * 10 * [0.,80.] * P2BM5 * sbw1bm * 14 * R*4 * 10 * [0.,80.] * P2BM5 * sbw2bm * 15 * R*4 * 10 * [0.,80.] * P2BM5 * sbw1rs * 16 * R*4 * 10 * [0.,80.] * P2BM5 * sbw2rs * 1 * U*4 * 4 * [0,14] * P2BM6 * CKNMU * 2 * R*4 * 12 * [-100.,100.] * P2BM6 * CKTMU * 3 * R*4 * 12 * [-100.,100.] * P2BM6 * CKTMU2 * 4 * U*4 * 4 * [0,14] * P2BM6 * CPINMU * 5 * R*4 * 12 * [-100.,100.] * P2BM6 * CPITMU * 6 * R*4 * 12 * [-100.,100.] * P2BM6 * CPITMU2 * 7 * R*4 * 12 * [-100.,100.] * P2BM6 * BW1TMU * 8 * R*4 * 12 * [-100.,100.] * P2BM6 * BW1HMU * 9 * R*4 * 12 * [-100.,100.] * P2BM6 * BW2TMU * 10 * R*4 * 12 * [-100.,100.] * P2BM6 * BW2HMU * 11 * R*4 * 12 * [0.,10.] * P2BM6 * B4EMU * 12 * R*4 * 12 * [-100.,100.] * P2BM6 * B4HMU * 1 * U*4 * 4 * [0,14] * P2BM7 * CKNMU_CCD * 2 * R*4 * 12 * [-100.,100.] * P2BM7 * CKTMU_CCD * 3 * R*4 * 12 * [-100.,100.] * P2BM7 * CKTMU2_CCD * 4 * U*4 * 4 * [0,14] * P2BM7 * CPINMU_CCD * 5 * R*4 * 12 * [-100.,100.] * P2BM7 * CPITMU_CCD * 6 * R*4 * 12 * [-100.,100.] * P2BM7 * CPITMU2_CCD * 7 * R*4 * 12 * [0.,10.] * P2BM7 * B4EMU_CCD * 8 * R*4 * 12 * [-100.,100.] * P2BM7 * B4HMU_CCD * 1 * R*4 * 12 * [-30.,70.] * P2BM8 * CKTBM_CCD * 2 * R*4 * 12 * [-30.,30.] * P2BM8 * CKTRS_CCD * 3 * R*4 * 12 * [-30.,30.] * P2BM8 * CKTBM2_CCD * 4 * R*4 * 12 * [-30.,30.] * P2BM8 * CKTRS2_CCD * 5 * R*4 * 12 * [-30.,70.] * P2BM8 * CPITBM_CCD * 6 * R*4 * 12 * [-30.,30.] * P2BM8 * CPITRS_CCD * 7 * R*4 * 12 * [-30.,30.] * P2BM8 * CPITBM2_CCD * 8 * R*4 * 12 * [-30.,30.] * P2BM8 * CPITRS2_CCD * 9 * U*4 * 4 * [0,15] * P2BM8 * CKNBM_CCD * 10 * U*4 * 4 * [0,15] * P2BM8 * CKNRS_CCD * 11 * U*4 * 4 * [0,15] * P2BM8 * CPINBM_CCD * 12 * U*4 * 4 * [0,15] * P2BM8 * CPINRS_CCD * 1 * R*4 * 10 * [0.,8.] * P2BM9 * B4ABM_CCD * 2 * R*4 * 12 * [-30.,70.] * P2BM9 * B4TBM_CCD * 3 * R*4 * 10 * [0.,8.] * P2BM9 * B4ARS_CCD * 4 * R*4 * 12 * [-30.,30.] * P2BM9 * B4TRS_CCD * 5 * R*4 * 12 * [-50.,50.] * P2BM9 * B4DTBM_CCD * 6 * R*4 * 12 * [-30.,30.] * P2BM9 * B4HRS_CCD * 7 * R*4 * 10 * [0.,8.] * P2BM9 * B4ERS_CCD * 8 * R*4 * 12 * [-50.,50.] * P2BM9 * PVCBM(4) * 9 * R*4 * 12 * [-50.,50.] * P2BM9 * PVCRS(4) * 10 * R*4 * 12 * [-50.,50.] * P2BM9 * B0CBM * 11 * R*4 * 12 * [-50.,50.] * P2BM9 * B0CRS * 1 * U*4 * 3 * [0,5] * P2BM10 * ADSTAT * 2 * U*4 * 5 * [0,30] * P2BM10 * ADHIT * 3 * U*4 * 4 * [0,12] * P2BM10 * ADNBM * 4 * U*4 * 4 * [0,12] * P2BM10 * ADNRS * 5 * R*4 * 10 * [0.,20.] * P2BM10 * ADABM * 6 * R*4 * 10 * [0.,20.] * P2BM10 * ADARS * 7 * R*4 * 12 * [-50.,50.] * P2BM10 * ADTBM * 8 * R*4 * 12 * [-50.,50.] * P2BM10 * ADTRS * 9 * U*4 * 6 * [0,50] * P2BM10 * ADHIT2 * 10 * U*4 * 4 * [0,15] * P2BM10 * ADNBM2 * 11 * U*4 * 4 * [0,15] * P2BM10 * ADNRS2 * 12 * R*4 * 10 * [0.,20.] * P2BM10 * ADABM2 * 13 * R*4 * 10 * [0.,20.] * P2BM10 * ADARS2 * 14 * R*4 * 12 * [-50.,50.] * P2BM10 * ADTBM2 * 15 * R*4 * 12 * [-50.,50.] * P2BM10 * ADTRS2 * 1 * R*4 * 12 * [-100.,100.] * P2BM11 * B4STR_CCD * 1 * I*4 * * [0,100] * P2BM14 * nbmb4 * 2 * U*4 * 6 * [0,32] * P2BM14 * elembmb4(nbmb4) * 3 * R*4 * 12 * [-100.,200.] * P2BM14 * tbmb4(nbmb4) * 4 * R*4 * 10 * [0.,8.] * P2BM14 * ebmb4(nbmb4) * 5 * R*4 * 10 * [-10.,10.] * P2BM14 * xb4bm * 6 * R*4 * 10 * [-10.,10.] * P2BM14 * yb4bm * 7 * R*4 * 10 * [-10.,10.] * P2BM14 * xb4rs * 8 * R*4 * 10 * [-10.,10.] * P2BM14 * yb4rs * 9 * I*4 * * [0,360] * P2BM14 * nbmbw * 10 * U*4 * 9 * [0,505] * P2BM14 * elembmbw(nbmbw) * 11 * R*4 * 12 * [-200.,200.] * P2BM14 * tbmbw(nbmbw) * 12 * R*4 * 12 * [0.,300.] * P2BM14 * wbmbw(nbmbw) * 13 * R*4 * 12 * [-100.,100.] * P2BM14 * xbw1bm * 14 * R*4 * 12 * [-100.,100.] * P2BM14 * ybw1bm * 15 * R*4 * 12 * [-100.,100.] * P2BM14 * xbw2bm * 16 * R*4 * 12 * [-100.,100.] * P2BM14 * ybw2bm * 17 * R*4 * 12 * [-100.,100.] * P2BM14 * xbw1rs * 18 * R*4 * 12 * [-100.,100.] * P2BM14 * ybw1rs * 19 * R*4 * 12 * [-100.,100.] * P2BM14 * xbw2rs * 20 * R*4 * 12 * [-100.,100.] * P2BM14 * ybw2rs * 21 * I*4 * * [0,150] * P2BM14 * nbmck * 22 * U*4 * 4 * [0,14] * P2BM14 * elembmck(nbmck) * 23 * R*4 * 12 * [-100.,200.] * P2BM14 * tbmck(nbmck) * 24 * R*4 * 12 * [0.,300.] * P2BM14 * wbmck(nbmck) * 25 * I*4 * * [0,150] * P2BM14 * nbmcp * 26 * U*4 * 4 * [0,14] * P2BM14 * elembmcp(nbmcp) * 27 * R*4 * 12 * [-100.,200.] * P2BM14 * tbmcp(nbmcp) * 28 * R*4 * 12 * [0.,300.] * P2BM14 * wbmcp(nbmcp) * 1 * I*4 * * [0,14] * P2BM17 * nckfit * 2 * U*4 * 4 * [0,14] * P2BM17 * elckfit(nckfit) * 3 * R*4 * 12 * [-150.,150.] * P2BM17 * cktraw(nckfit) * 4 * U*4 * 4 * [0,10] * P2BM17 * cknpul(nckfit) * 5 * R*4 * 16 * [0.,3000.] * P2BM17 * CKFITX(2,nckfit) * 6 * R*4 * 16 * [0.,10000.] * P2BM17 * CKFITA(2,2,nckfit) * 7 * R*4 * 12 * [-10.,70.] * P2BM17 * CKFITT(2,2,nckfit) * 8 * R*4 * 10 * [0.,1.] * P2BM17 * CKFITP(2,nckfit) * 9 * U*4 * 7 * [0,120] * P2BM17 * nckfitd(2,nckfit) * 10 * I*4 * * [0,14] * P2BM17 * ncpifit * 11 * U*4 * 4 * [0,14] * P2BM17 * elcpifit(ncpifit) * 12 * R*4 * 12 * [-150.,150.] * P2BM17 * cpitraw(ncpifit) * 13 * U*4 * 4 * [0,10] * P2BM17 * cpinpul(ncpifit) * 14 * R*4 * 16 * [0.,3000.] * P2BM17 * CPIFITX(2,ncpifit) * 15 * R*4 * 16 * [0.,10000.] * P2BM17 * CPIFITA(2,2,ncpifit) * 16 * R*4 * 12 * [-10.,70.] * P2BM17 * CPIFITT(2,2,ncpifit) * 17 * R*4 * 10 * [0.,1.] * P2BM17 * CPIFITP(2,ncpifit) * 18 * U*4 * 7 * [0,120] * P2BM17 * ncpifitd(2,ncpifit) * 19 * I*4 * * [0,20] * P2BM17 * nb4fit * 20 * U*4 * 6 * [0,32] * P2BM17 * elb4fit(nb4fit) * 21 * R*4 * 12 * [0.,250.] * P2BM17 * b4eraw(nb4fit) * 22 * R*4 * 12 * [-150.,150.] * P2BM17 * b4traw(nb4fit) * 23 * U*4 * 4 * [0,10] * P2BM17 * b4npul(nb4fit) * 24 * R*4 * 16 * [0.,3000.] * P2BM17 * B4FITX(2,nb4fit) * 25 * R*4 * 16 * [0.,10000.] * P2BM17 * B4FITA(2,2,nb4fit) * 26 * R*4 * 12 * [-10.,70.] * P2BM17 * B4FITT(2,2,nb4fit) * 27 * R*4 * 10 * [0.,1.] * P2BM17 * B4FITP(2,nb4fit) * 28 * U*4 * 7 * [0,120] * P2BM17 * nb4fitd(2,nb4fit) * 1 * R*4 * 12 * [0.,500.] * P2BM18 * cknpebm * 2 * R*4 * 12 * [0.,500.] * P2BM18 * cknpers * 3 * R*4 * 12 * [0.,500.] * P2BM18 * cpinpebm * 4 * R*4 * 12 * [0.,500.] * P2BM18 * cpinpers * 5 * I*4 * 10 * [-10,500] * P2BM18 * adpuld(40,3) * 6 * I*4 * 10 * [-10,500] * P2BM18 * b4puld(40,3) * 7 * I*4 * 10 * [-10,500] * P2BM18 * ckpuld(40,3) * 8 * I*4 * 10 * [-10,500] * P2BM18 * cpipuld(40,3) * 1 * U*4 * 2 * [0,3] * P2BM19 * IBSQUALT_ATC * 2 * U*4 * 5 * [0,17] * P2BM19 * IB4KFIN_ATC(2) * 3 * R*4 * 12 * [-100.,100.] * P2BM19 * B4STR_ATC * 4 * R*4 * 12 * [-100.,100.] * P2BM19 * B4NEARRS_ATC * 5 * R*4 * 12 * [-100.,100.] * P2BM19 * B4NEAR0_ATC * 6 * R*4 * 12 * [-100.,100.] * P2BM19 * B4UVSTR_ATC(2) * 1 * R*4 * 10 * [0.,8.] * P2BM20 * B4ABM_ATC * 2 * R*4 * 12 * [-30.,70.] * P2BM20 * B4TBM_ATC * 3 * R*4 * 10 * [0.,8.] * P2BM20 * B4ARS_ATC * 4 * R*4 * 12 * [-30.,30.] * P2BM20 * B4TRS_ATC * 5 * R*4 * 12 * [-50.,50.] * P2BM20 * B4DTBM_ATC * 6 * R*4 * 12 * [-30.,30.] * P2BM20 * B4HRS_ATC * 7 * R*4 * 10 * [0.,8.] * P2BM20 * B4ERS_ATC * 8 * U*4 * 2 * [0,3] * P2BM20 * B4NPBM_ATC * 9 * U*4 * 3 * [0,5] * P2BM20 * B4NHBM_ATC * 10 * U*4 * 2 * [0,3] * P2BM20 * B4NPRS_ATC * 11 * U*4 * 3 * [0,5] * P2BM20 * B4NHRS_ATC * 12 * R*4 * 10 * [-10.,10.] * P2BM20 * xb4bm_atc * 13 * R*4 * 10 * [-10.,10.] * P2BM20 * yb4bm_atc * 14 * R*4 * 10 * [-10.,10.] * P2BM20 * xb4rs_atc * 15 * R*4 * 10 * [-10.,10.] * P2BM20 * yb4rs_atc * 1 * I*4 * * [0,50] * P2RD * NCNTR * 2 * R*4 * 10 * [-10.,10.] * P2RD * TDIFF(NCNTR) * 3 * R*4 * 10 * [-10.,100.] * P2RD * TMEAN(NCNTR) * 4 * R*4 * 10 * [-10.,10.] * P2RD * TDIFFTD(NCNTR) * 5 * R*4 * 10 * [-10.,100.] * P2RD * TMEANTD(NCNTR) * 6 * U*4 * 4 * [0,10] * P2RD * IMULT(NCNTR) * 7 * U*4 * 9 * [1,504] * P2RD * IMODRD(NCNTR) * 8 * R*4 * 10 * [0.,150.] * P2RD * ECOMRD(NCNTR) * 9 * R*4 * 10 * [-100.,100.] * P2RD * ZRD(NCNTR) * 10 * R*4 * 11 * [-60.,60.] * P2RD * ZUTC(NCNTR) * 11 * R*4 * 12 * [-1.,4000.] * P2RD * TDAREA1(NCNTR) * 12 * R*4 * 12 * [-1.,4000.] * P2RD * TDAREA2(NCNTR) * 13 * R*4 * 10 * [-1.,256.] * P2RD * TDHGT1(NCNTR) * 14 * R*4 * 10 * [-1.,256.] * P2RD * TDHGT2(NCNTR) * 15 * R*4 * 12 * [0.,600.] * P2RD * EFROMPH(NCNTR) * 16 * L*4 * 1 * * P2RD * LGCORR(NCNTR) * 17 * I*4 * * [0,50] * P2RD * NCNTR2 * 18 * U*4 * 9 * [1,504] * P2RD * IMODRD2(NCNTR2) * 19 * U*4 * 4 * [0,10] * P2RD * ISTAT_FITPI(NCNTR2) * 20 * R*4 * 10 * [-10.,90.] * P2RD * TPI1(NCNTR2) * 21 * R*4 * 10 * [-10.,90.] * P2RD * TPI2(NCNTR2) * 22 * R*4 * 9 * [0.,120.] * P2RD * TMU1(NCNTR2) * 23 * R*4 * 9 * [0.,120.] * P2RD * TMU2(NCNTR2) * 24 * R*4 * 12 * [0.,4000.] * P2RD * EPI1(NCNTR2) * 25 * R*4 * 12 * [0.,4000.] * P2RD * EPI2(NCNTR2) * 26 * R*4 * 12 * [0.,4000.] * P2RD * EMU1(NCNTR2) * 27 * R*4 * 12 * [0.,4000.] * P2RD * EMU2(NCNTR2) * 28 * R*4 * 9 * [0.,100.] * P2RD * CHIMP1(NCNTR2) * 29 * R*4 * 9 * [0.,100.] * P2RD * CHIMP2(NCNTR2) * 30 * I*4 * * [0,20] * P2RD * NLAY_RS * 31 * R*4 * 10 * [-1.,5.] * P2RD * LOG_DE_EXP(NLAY_RS) * 32 * R*4 * 11 * [0.,5.] * P2RD * DX_MEAS(NLAY_RS) * 33 * R*4 * 10 * [-1.,5.] * P2RD * LOG_DE_MEAS(NLAY_RS) * 1 * I*4 * * [0,20] * EV5TDC * NCOINS * 2 * U*4 * 5 * [0,20] * EV5TDC * NCOINF * 3 * U*4 * 5 * [0,20] * EV5TDC * NCOINC * 4 * U*4 * 7 * [0,127] * EV5TDC * TOTLHITS(NCOINS) * 5 * U*4 * 5 * [0,19] * EV5TDC * MINLAYS(NCOINS) * 6 * U*4 * 5 * [0,19] * EV5TDC * MAXLAYS(NCOINS) * 7 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBAVER(NCOINS) * 8 * R*4 * 12 * [-25.,25.] * EV5TDC * DTCLOSE(NCOINS) * 9 * R*4 * 15 * [0.,200.] * EV5TDC * ENER(NCOINS) * 10 * U*4 * 7 * [0,127] * EV5TDC * NCNTREV5(NCOINS) * 11 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBALLH(20,NCOINS) * 12 * R*4 * 12 * [-20.,20.] * EV5TDC * TDALLH(20,NCOINS) * 13 * U*4 * 5 * [0,19] * EV5TDC * LYALLH(20,NCOINS) * 14 * U*4 * 5 * [0,24] * EV5TDC * SCALLH(20,NCOINS) * 15 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBALLW(20,NCOINS) * 16 * R*4 * 12 * [-20.,20.] * EV5TDC * TDALLW(20,NCOINS) * 17 * U*4 * 5 * [0,19] * EV5TDC * LYALLW(20,NCOINS) * 18 * U*4 * 5 * [0,24] * EV5TDC * SCALLW(20,NCOINS) * 19 * I*4 * * [0,20] * EV5TDC * NCOINS_ * 20 * U*4 * 5 * [0,20] * EV5TDC * NCOINF_ * 21 * U*4 * 5 * [0,20] * EV5TDC * NCOINC_ * 22 * U*4 * 7 * [0,127] * EV5TDC * TOTLHITS_(NCOINS_) * 23 * U*4 * 5 * [0,19] * EV5TDC * MINLAYS_(NCOINS_) * 24 * U*4 * 5 * [0,19] * EV5TDC * MAXLAYS_(NCOINS_) * 25 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBAVER_(NCOINS_) * 26 * R*4 * 12 * [-25.,25.] * EV5TDC * DTCLOSE_(NCOINS_) * 27 * R*4 * 15 * [0.,200.] * EV5TDC * ENER_(NCOINS_) * 28 * U*4 * 7 * [0,127] * EV5TDC * NCNTREV5_(NCOINS_) * 29 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBALLH_(20,NCOINS_) * 30 * R*4 * 12 * [-20.,20.] * EV5TDC * TDALLH_(20,NCOINS_) * 31 * U*4 * 5 * [0,19] * EV5TDC * LYALLH_(20,NCOINS_) * 32 * U*4 * 5 * [0,24] * EV5TDC * SCALLH_(20,NCOINS_) * 33 * R*4 * 16 * [-1000.,1100 * EV5TDC * TBALLW_(20,NCOINS_) * 34 * R*4 * 12 * [-20.,20.] * EV5TDC * TDALLW_(20,NCOINS_) * 35 * U*4 * 5 * [0,19] * EV5TDC * LYALLW_(20,NCOINS_) * 36 * U*4 * 5 * [0,24] * EV5TDC * SCALLW_(20,NCOINS_) * 1 * I*4 * * [0,1152] * P2UTCH * NXYHIT * 2 * I*4 * * [0,24] * P2UTCH * NHITXY * 3 * U*4 * 11 * [1,1152] * P2UTCH * IWIRE(NXYHIT) * 4 * L*4 * 1 * * P2UTCH * XY_USED(NXYHIT) * 5 * R*4 * 12 * [0.,1.5] * P2UTCH * DRIFT_DIST(NXYHIT) * 6 * R*4 * 10 * [0.,4000.] * P2UTCH * WIRE_ADC(NXYHIT) * 7 * R*4 * 10 * [0.,250.] * P2UTCH * WIRE_TIME(NXYHIT) * 8 * R*4 * * * P2UTCH * XYRES(NHITXY) * 9 * U*4 * 11 * [1,1152] * P2UTCH * WIREID(NHITXY) * 10 * I*4 * * [0,30] * P2UTCH * NZHIT * 11 * I*4 * * [0,6] * P2UTCH * NHITZ * 12 * U*4 * 3 * [1,6] * P2UTCH * FOILZ(NZHIT) * 13 * R*4 * * * P2UTCH * ZPOS(NHITZ) * 14 * R*4 * * * P2UTCH * ZRES(NHITZ) * 15 * R*4 * 10 * [0.,250.] * P2UTCH * FOIL_TIME(NZHIT) * 16 * U*4 * 4 * [0,10] * P2UTCH * NSTRIP(NZHIT) * 17 * I*4 * * [0,300] * P2UTCH * NSTRIPS * 18 * R*4 * 10 * [0.,4000.] * P2UTCH * STRIP_ADC(NSTRIPS) * 19 * R*4 * 10 * [0.,250.] * P2UTCH * STRIP_TIM(NSTRIPS) * 20 * R*4 * 12 * [-30.,30.] * P2UTCH * STRIP_Z(NSTRIPS) * 21 * U*4 * 10 * [0,768] * P2UTCH * ISTRIP(NSTRIPS) * 1 * L*4 * 1 * * P2ERR * FERBANK * 2 * U*4 * 9 * [0,256] * P2ERR * IEVCODE * 3 * U*4 * 4 * [0,10] * P2ERR * IERRTDC * 1 * I*4 * * [0,28] * P2RSSC * NSC1 * 2 * U*4 * 5 * [0,27] * P2RSSC * WIRESC1(NSC1) * 3 * I*4 * 8 * [-10,90] * P2RSSC * TSC1(NSC1) * 4 * U*4 * 11 * [500,2000] * P2RSSC * WIDSC1(NSC1) * 5 * R*4 * 12 * [-100.,100.] * P2RSSC * ZSC1(NSC1) * 6 * I*4 * * [0,28] * P2RSSC * NSC2 * 7 * U*4 * 5 * [0,27] * P2RSSC * WIRESC2(NSC2) * 8 * I*4 * 8 * [-10,90] * P2RSSC * TSC2(NSC2) * 9 * U*4 * 11 * [500,2000] * P2RSSC * WIDSC2(NSC2) * 10 * R*4 * 12 * [-100.,100.] * P2RSSC * ZSC2(NSC2) * 11 * R*4 * * * P2RSSC * RSZ1_N * 12 * R*4 * * * P2RSSC * RSZ2_N * 13 * R*4 * * * P2RSSC * RSZ1D_N * 14 * R*4 * * * P2RSSC * RSZ2D_N * 1 * I*4 * * [0,15] * P2RDPATH * NSEG * 2 * R*4 * 14 * [-200.,200.] * P2RDPATH * XSEG(NSEG) * 3 * R*4 * 14 * [-200.,200.] * P2RDPATH * YSEG(NSEG) * 4 * R*4 * 12 * [0.,6.3] * P2RDPATH * PSEG1(NSEG) * 5 * R*4 * 12 * [0.,6.3] * P2RDPATH * PSEG2(NSEG) * 6 * R*4 * 12 * [-90.,90.] * P2RDPATH * ZSEG1(NSEG) * 7 * R*4 * 12 * [-90.,90.] * P2RDPATH * ZSEG2(NSEG) * 8 * R*4 * 12 * [0.,100.] * P2RDPATH * RSEG(NSEG) * 9 * L*4 * 1 * * P2RDPATH * PLUSSEG(NSEG) * 10 * R*4 * 10 * [0.,50.] * P2RDPATH * LSEG(NSEG) * 11 * I*4 * 10 * * P2RDPATH * TYPSEG(NSEG) * 1 * I*4 * * [0,50] * P2RNGBNK * NSTP * 2 * R*4 * 14 * [-200.,200.] * P2RNGBNK * XSTP(NSTP) * 3 * R*4 * 14 * [-200.,200.] * P2RNGBNK * YSTP(NSTP) * 4 * R*4 * 12 * [0.,6.3] * P2RNGBNK * PSTP1(NSTP) * 5 * R*4 * 12 * [0.,6.3] * P2RNGBNK * PSTP2(NSTP) * 6 * R*4 * 12 * [-90.,90.] * P2RNGBNK * ZSTP1(NSTP) * 7 * R*4 * 12 * [-90.,90.] * P2RNGBNK * ZSTP2(NSTP) * 8 * R*4 * 12 * [0.,100.] * P2RNGBNK * RSTP(NSTP) * 1 * U*4 * 2 * [0,2] * TGICUNP * nerr_tg * 2 * I*4 * * [0,500] * TGICUNP * nall_tg * 3 * U*4 * 10 * [0,576] * TGICUNP * elall_tg(nall_tg) * 4 * R*4 * 10 * [-20.,80.] * TGICUNP * tall_tg(nall_tg) * 5 * R*4 * 10 * [0.,100.] * TGICUNP * eall_tg(nall_tg) * 6 * U*4 * 2 * [0,2] * TGICUNP * nerr_tgccd * 7 * I*4 * * [0,500] * TGICUNP * nall_tgccd * 8 * U*4 * 10 * [0,576] * TGICUNP * elall_tgccd(nall_tgccd) * 9 * R*4 * 10 * [-20.,80.] * TGICUNP * tall_tgccd(nall_tgccd) * 10 * R*4 * 10 * [0.,1000.] * TGICUNP * eall_tgccd(nall_tgccd) * 11 * U*4 * 2 * [0,2] * TGICUNP * nerr_ic * 12 * I*4 * * [0,50] * TGICUNP * nall_ic * 13 * U*4 * 3 * [0,6] * TGICUNP * elall_ic(nall_ic) * 14 * R*4 * 10 * [-20.,80.] * TGICUNP * tall_ic(nall_ic) * 15 * R*4 * 10 * [0.,50.] * TGICUNP * eall_ic(nall_ic) * 16 * U*4 * 2 * [0,2] * TGICUNP * nerr_ictd * 17 * I*4 * * [0,50] * TGICUNP * nall_ictd * 18 * U*4 * 3 * [0,6] * TGICUNP * elall_ictd(nall_ictd) * 19 * R*4 * 10 * [-20.,80.] * TGICUNP * tall_ictd(nall_ictd) * 20 * R*4 * 10 * [0.,300.] * TGICUNP * hall_ictd(nall_ictd) * 1 * I*4 * * [0,63] * PILEUP * ntdic * 2 * U*4 * 3 * [1,6] * PILEUP * eltdic(ntdic) * 3 * R*4 * 12 * [-100.,100.] * PILEUP * tdtic(ntdic) * 4 * R*4 * 9 * [0.,20.] * PILEUP * tdaic(ntdic) * 1 * I*4 * * [0,100] * CUTNAMES * ncuts * 2 * C*32 * * * CUTNAMES * cutnames(ncuts) ****************************************************************** * Block * Entries * Unpacked * Packed * Packing Factor * ****************************************************************** * P1BASIC * 505 * 840 * 55 * 15.273 * * P1TDOUT * 505 * 112 * 40 * 2.800 * * P1TDOUT2 * 505 * 64 * 24 * 2.667 * * P1TDOUT3 * 505 * 100 * 38 * 2.632 * * P1UTCRS * 505 * 188 * 64 * 2.938 * * P1UTCRS2 * 505 * 148 * Var. * Variable * * P1UTCRS3 * 505 * 48 * 11 * 4.364 * * TDPLS * 505 * 4144 * Var. * Variable * * TDPLS3 * 505 * 3104 * Var. * Variable * * P1NEW * 505 * 100 * 32 * 3.125 * * RSRATE * 505 * 40 * 15 * 2.667 * * RDZ * 505 * 340 * Var. * Variable * * L11 * 505 * 460 * Var. * Variable * * TDPROMPT * 505 * 144 * 144 * 1.000 * * TDERROR * 505 * 5136 * Var. * Variable * * UTCTT * 505 * 36 * 22 * 1.636 * * P2KIN * 505 * 60 * 17 * 3.529 * * P2TG1 * 505 * 14616 * Var. * Variable * * P2TG2 * 505 * 96 * 28 * 3.429 * * P2TG3 * 505 * 8044 * Var. * Variable * * P2TG4 * 505 * 7680 * Var. * Variable * * P2TG7 * 505 * 1268 * Var. * Variable * * P2TG8 * 505 * 1328 * Var. * Variable * * P2TD * 505 * 6348 * Var. * Variable * * P2PV1 * 505 * 18364 * Var. * Variable * * P2PV2 * 505 * 6196 * Var. * Variable * * P2PV3 * 505 * 5904 * Var. * Variable * * P2PV6 * 505 * 5232 * Var. * Variable * * P2PV7 * 505 * 576 * Var. * Variable * * P2PV8 * 505 * 5232 * Var. * Variable * * P2PV9 * 505 * 3216 * Var. * Variable * * P2BM1 * 505 * 48 * 14 * 3.429 * * P2BM2 * 505 * 60 * 22 * 2.727 * * P2BM3 * 505 * 32 * 11 * 2.909 * * P2BM4 * 505 * 32 * 9 * 3.556 * * P2BM5 * 505 * 64 * 13 * 4.923 * * P2BM6 * 505 * 48 * 16 * 3.000 * * P2BM7 * 505 * 32 * 10 * 3.200 * * P2BM8 * 505 * 48 * 14 * 3.429 * * P2BM9 * 505 * 68 * 25 * 2.720 * * P2BM10 * 505 * 60 * 15 * 4.000 * * P2BM11 * 505 * 4 * 2 * 2.000 * * P2BM14 * 505 * 9184 * Var. * Variable * * P2BM17 * 505 * 3356 * Var. * Variable * * P2BM18 * 505 * 1936 * 606 * 3.195 * * P2BM19 * 505 * 32 * 9 * 3.556 * * P2BM20 * 505 * 60 * 16 * 3.750 * * P2RD * 505 * 5652 * Var. * Variable * * EV5TDC * 505 * 26744 * Var. * Variable * * P2UTCH * 505 * 28460 * Var. * Variable * * P2ERR * 505 * 12 * 2 * 6.000 * * P2RSSC * 505 * 920 * Var. * Variable * * P2RDPATH * 505 * 604 * Var. * Variable * * P2RNGBNK * 505 * 1404 * Var. * Variable * * TGICUNP * 505 * 13232 * Var. * Variable * * PILEUP * 505 * 760 * Var. * Variable * * CUTNAMES * 505 * 3204 * Var. * Variable * * Total * --- * 195220 * Var. * Variable * ****************************************************************** * Blocks = 57 Variables = 1026 Max. Columns = 48105 * ****************************************************************** By popular demand, I present the first installment of pass2 ntuple variable descriptions. Since I am simply going through from top to bottom, it may be a couple of days or so before I get to your favorite unexplained variable. Please do not hesitate to ask questions like, "Hey, Joe, what the hell is ELSABTBV?" , or conversely, "Hey, Joe, how on earth can I find out the BV module numbers for all those hits that have ADC info. on one end, and TDC info. on both ends?" if you need help in the mean time. Joe Pass2 ntuple variable descriptions, part 1. P1BASIC * run Run # P1BASIC * event Event # within RUN P1BASIC * splno Spill # within RUN P1BASIC * splrec Spill ntuple record # in EOS ntuple P1BASIC * scal_tsp Time of event in spill P1BASIC * scal_io2 Your guess as good as mine! The common P1BASIC * scal_io3 block comment in tr2bits.cmn says: "INTEGER IO_TIME(3) ! three times (20 ns/count)" P1BASIC * skim(10) .TRUE. if skim stream(1-10) cuts passed P1BASIC * cut(100) .TRUE. if cut(1-100) _failed_ P1BASIC * icut Index of the LAST cut failed (not very useful) P1BASIC * lay Stopping layer as found by RD_TRK P1BASIC * tlay Stopping layer as found by online SCF P1BASIC * sec Stopping sector as found by RD_TRK P1BASIC * tsec T.2 sector as found by online SCF P1BASIC * ssec Stopping sector as found by online SCF P1BASIC * thex Stopping hextant as found by online SCF P1BASIC * t2sec T.2 sector as found by RD_TRK P1BASIC * trs Track time as found by trktim_rd P1BASIC * erd RS energy as found by RD_TRK P1BASIC * lct(21) RS layer hit bits (l_ct in tr2bits.cmn) P1BASIC * ext(25) EXT_CON array from tr2bits.cmn P1BASIC * lev0(16) Level 0 trigger bits P1BASIC * lhex Online hextant bit (.TRUE. if passed) P1BASIC * hhex(6) Hextant hit bits from tr2bits.cmn P1BASIC * l0z Level 0 z info. (from "refined range" info.) P1BASIC * l11 Level 1.1 trigger bit P1BASIC * l12 Level 1.2 trigger bit P1BASIC * tavgz Average level 0 z measurement P1BASIC * tntg # hit target elements (online) P1BASIC * rsintime Prompt energy in RS at TRS (intime.F) P1BASIC * ustop_hex .TRUE. If UMC stopping hextant found properly P1TDOUT * ipiflg FITPI return code P1TDOUT * cmupi1(2) Chisq ratio for single/double pulse fits (both ends) P1TDOUT * tmuon1(2) Mu time (relative to pi time) for both ends P1TDOUT * emuon1(2) Uncalibrated mu energy (i.e. TD pulse areas) P1TDOUT * emuonc1(2) Calibrated mu energy P1TDOUT * dt1 End-to-end muon time difference P1TDOUT * emut1 Uncalibrated total mu energy P1TDOUT * emutc1 Calibrated total mu energy P1TDOUT * prod1 Chisq ratio product for both ends P1TDOUT * tmuav1 Average mu time P1TDOUT * muped1(2) pedestal level from single-pulse fit P1TDOUT * piped1(2) pedestal level from double-pulse fit P1TDOUT * cmuend1(2) chisq from single-pulse fit (both ends) P1TDOUT * cpiend1(2) chisq from double-pulse fit (both ends) P1TDOUT * tpion1(2) pion time (both ends) P1TDOUT * epion1(2) uncalibrated pion energy (both ends) P1TDOUT * epionc1(2) calibrated pion energy (both ends) P1UTCRS * ers RS energy as measured by trkrng P1UTCRS * rrs RS range as measured by trkrng P1UTCRS * layv4 Stopping layer as found by trkrng P1UTCRS * secv4 Stopping sector as found by trkrng P1UTCRS * cos3d Dip angle of UTC track P1UTCRS * pdc Total momentum of UTC track P1UTCRS * ndclay # Hit layers of UTC track P1UTCRS * zf z stop position in RS (info. from trkrng) P1UTCRS * elast Uncorrected stopping counter energy from trkrng P1UTCRS * elast_cor Elast, unsaturated, and mu energy subtracted P1UTCRS * tk K stop time from swath P1UTCRS * tpi pi stop time from swath P1UTCRS * ictpi 1 if pi time really from IC time P1UTCRS * itgqualt swath return code P1UTCRS * etg pi energy from swath P1UTCRS * rtg pi range from swath P1UTCRS * tgx x position of K stop from swath P1UTCRS * tgy y position of K stop from swath P1UTCRS * tgz z position of K stop from swath P1UTCRS * ek K energy from swath P1UTCRS * eic I-counter energy P1UTCRS * ric I-counter range P1UTCRS * eicest I-counter energyestimated from range P1UTCRS * ptot total momentum, corrected using target range P1UTCRS * ptote total momentum, corrected using target energy P1UTCRS * rtot total range P1UTCRS * etot total energy P1UTCRS * b4strob b4 hit closest to K stop time P1UTCRS * tdot2t time of T.2 hit P1UTCRS * ictime time of I-counter hit P1UTCRS * tds time of detector strobe P1UTCRS * rsz1d Residuals for RSSC z clusters P1UTCRS * rsz2d Residuals for RSSC z clusters P1UTCRS * rsz1d2 Residuals for RSSC z closest hits P1UTCRS * rsz2d2 Residuals for RSSC z closest hits P1UTCRS * zutout z exit point of UTC track from UTC P1UTCRS * radius radius of curvature for UTC track P1UTCRS * d0 P.C.A. of UTC track w.r.t. (tgx,tgy) P1UTCRS * phi0 track direction at P.C.A. P1UTCRS * tanl tan(UTC dip angle) P1UTCRS * nhxy # x/y hits in UTC fit P1UTCRS * nhz # z hits in UTC fit P1UTCRS * chidfxy chisq/d.o.f. for x/y fit P1UTCRS * chidfz chisq/d.o.f. for z fit P1UTCRS * rsxy1d Residuals for RSSC xy hits P1UTCRS * rsxy2d Residuals for RSSC xy hits P1UTCRS2 * ncross # RS sector crossings P1UTCRS2 * rscrsd(ncross) Residuals for RS sector crossing P1UTCRS2 * rsr1 Radius of RSSC hit P1UTCRS2 * rsp1 Phi position of RSSC hit P1UTCRS2 * rsz1 z position of RSSC P1UTCRS2 * rsr2 Radius of RSSC hit P1UTCRS2 * rsp2 Phi position of RSSC hit P1UTCRS2 * rsz2 z position of RSSC P1UTCRS2 * rscrsr(ncross) sector crossing radius P1UTCRS2 * rscrsp(ncross) sector crossing phi position P1UTCRS3 * iicout I-counter module for UTC track (outer) P1UTCRS3 * iicin I-counter module for UTC track (inner) P1UTCRS3 * eicout Track energy in outer IC module P1UTCRS3 * eicin Track energy in inner IC module P1UTCRS3 * ticout Track time in outer IC module P1UTCRS3 * ticin Track time in inner IC module P1UTCRS3 * tdtic_i TD measurement of IC inner time P1UTCRS3 * tdtic_o TD measurement of IC outer time P1UTCRS3 * tdaic_i TD measurement of IC inner energy P1UTCRS3 * tdaic_o TD measurement of IC outer energy TDPLS * NRAW1 All variables in this block are TDPLS * NPS1 concerned with plotting the TD TDPLS * PEDS1 pulse shapes and fit functions TDPLS * NP1D1 via paw_photo . A detailed description TDPLS * NP2D1 will not be given. TDPLS * PEDD1 | TDPLS * NRAW2 | TDPLS * NPS2 | TDPLS * PEDS2 | TDPLS * NP1D2 | TDPLS * NP2D2 | TDPLS * PEDD2 | TDPLS * TDFRAW1(NRAW1) | TDPLS * TDFPS1(NPS1) | TDPLS * TDFP1D1(NP1D1) | TDPLS * TDFP2D1(NP2D1) | TDPLS * TDFRAW2(NRAW2) | TDPLS * TDFPS2(NPS2) | TDPLS * TDFP1D2(NP1D2) | TDPLS * TDFP2D2(NP2D2) V P1NEW * PR_RF RS x/y chisq prob. from trkrng P1NEW * PR_RFZ1 RS z chisq prob. from RSSC residuals P1NEW * PR_RFZ2 RS z chisq prob. from end-to-end timing P1NEW * PR_RFZ2B PR_RFZ2 from restricted hit selection P1NEW * LIKE swath: energy/time/distance pion likelihood function P1NEW * LIKE2 swath: distance-only pion likelihood function P1NEW * XIN swath: b4 x position of K entering TT P1NEW * YIN swath: b4 y position of K entering TT P1NEW * DB4 swath: distance between B4 hit and nearest fiber P1NEW * DB4TIP swath: distance between B4 and nearest extreme tip of K cluster P1NEW * DVXTIP swath: distance between found decay vertex and nearest tip P1NEW * QB4 swath: .TRUE. if B4 info was used on this event P1NEW * DVXPI swath: Distance from supposed K decay vertex to closest pi fiber P1NEW * KPIANG swath: Angle between K and pi P1NEW * DEXTIP swath: Distance between extreme tips of K cluster P1NEW * UTCHNU1 # unused x/y hits within 1.5cm of track in superlayer 1 P1NEW * UTCHNU2 # unused x/y hits within 1.5cm of track in superlayer 2 P1NEW * UTCHNU3 # unused x/y hits within 1.5cm of track in superlayer 3 P1NEW * LOGUTCQ Combined UTC likelihood for # hits, layers, unused hits P1NEW * LOGUTCQI(6) Individual UTC likelihoods for # hits, layers, unused hit UTCTT * cos3d1 Track parameters, target quantities for TT-unconstrained UTC fit UTCTT * radius1 | UTCTT * d01 | UTCTT * phi01 | UTCTT * tanl1 | UTCTT * chidfxy1 | UTCTT * nhxy1 | UTCTT * tgx1 | UTCTT * tgy1 | UTCTT * tkold | UTCTT * tpiold | UTCTT * NK_TG1 | UTCTT * ELK_TG1(NK_TG1) | UTCTT * NPI_TG1 | UTCTT * ELPI_TG1(NPI_TG1) V UTCMON * NHITXY # UTC x/y hits UTCMON * NHITZ # UTC z hits UTCMON * NLAYER(NHITXY) Layer number for each xy hit UTCMON * DRIFT_TIME(NHITXY) Drift times for those hits UTCMON * RESID(NHITXY) x/y residuals for those hits UTCMON * ADCW(NHITXY) ADC values for those hits UTCMON * ZRES(NHITZ) z residual for each z hit UTCMON * NFOIL(NHITZ) foil number for each z hit Pass2 ntuple variable descriptions, part 2. P2KIN * CL_EPRCOR Obsolete, unused variable P2KIN * DELTARP (Measured-expected) RRS as a function of PDC P2KIN * DELTARE (Measured-expected) RRS as a function of ERS (not used) P2KIN * SIG_P Momentum resoltion as a function of PDC P2KIN * SIG_E Energy resolution as a function of ERS (not used) N.b. The so-called "Range/momentum" cut that looks atDELTARP/SIG_P is invariably re-calibrated after pass2 has been run. P2KIN * FDEDX Obsolete, unused variable P2KIN * CL_RSDEDX RS dE/dx confidence limit P2KIN * CL_RSDEDX2 Obsolete, unused variable P2KIN * CHIMAX_RSDEDX Maximum individual layer RS dE/dx deviation P2KIN * LAY_CHIMAX The layer in which CHIMAX_RSDEDX occurred N.b. The dE/dx variables are invariably re-calibrated after pass2 has been run. P2KIN * NPRPAT Obsolete, unused variable P2KIN * DZUTSC14 Z match between UTC track extrapolation and RSSC hit in the sector immediately clockwise of the stopping sector. P2KIN * L14ACC Same as DZUTSC14 but on the opposite side of the detector P2KIN * ICODE_L14 Return code from LAY14 P2KIN * ICODE_L14ACC Return code from LAY14 on opposite side P2TG1 * NK_TG swath: # K fibers P2TG1 * TK_TG(NK_TG) swath: Times of all K fibers P2TG1 * EK_TG(NK_TG) swath: Energies of all K fibers P2TG1 * ELK_TG(NK_TG) swath: Module numbers of all K fibers P2TG1 * NPI_TG swath: # pi fibers P2TG1 * TPI_TG(NPI_TG) swath: Times of all pi fibers P2TG1 * EPI_TG(NPI_TG) swath: Energies of all pi fibers P2TG1 * ELPI_TG(NPI_TG) swath: Module numbers of all pi fibers P2TG1 * NPIOP_TG swath: # "opposite side" pi fibers P2TG1 * TPIOP_TG(NPIOP_TG) swath: Times of all "opposite side" pi fibers P2TG1 * EPIOP_TG(NPIOP_TG) swath: Energies of all "opposite side" pi fibers P2TG1 * ELPIOP_TG(NPIOP_TG) swath: Module numbers of all "opposite side" pi fibers P2TG1 * CCDTK(NK_TG) Same as TK_TG, except from CCD's P2TG1 * CCDEK(NK_TG) Same as EK_TG, except from CCD's P2TG1 * CCDHK(NK_TG) Pulse heights P2TG1 * CCDRK(NK_TG) Pulse rise times P2TG1 * LCCDK(NK_TG) .TRUE. if low-gain fiber P2TG1 * CCDTPI(NPI_TG) Same as TPI_TG, except from CCD's P2TG1 * CCDEPI(NPI_TG) Same as EPI_TG, except from CCD's P2TG1 * CCDHPI(NPI_TG) Pulse heights P2TG1 * CCDRPI(NPI_TG) Pulse rise times P2TG1 * LCCDPI(NPI_TG) .TRUE. if low-gain fiber P2TG1 * CCDTPIOP(NPIOP_TG) Same as TPIOP_TG, except from CCD's P2TG1 * CCDEPIOP(NPIOP_TG) Same as EPIOP_TG, except from CCD's P2TG1 * CCDHPIOP(NPIOP_TG) Pulse heights P2TG1 * CCDRPIOP(NPIOP_TG) Pulse rise times P2TG1 * LCCDPIOP(NPIOP_TG) .TRUE. if low-gain fiber P2TG1 * NEDGE_TG # of TT "edge fibers" hit P2TG1 * TEDGE_TG(NEDGE_TG) Times of those fibers P2TG1 * EEDGE_TG(NEDGE_TG) Energies of those fibers P2TG1 * ELEDGE_TG(NEDGE_TG) TT module numbers of those fibers P2TG2 * ETGVET_TG swath: Total gamma energy P2TG2 * NTGVET_TG swath: # of fibers with gamma energy P2TG2 * DIST_TARGF swath: closest distance between K and pi fibers P2TG2 * EPIMAX_TG Highest energy pi fiber P2TG2 * TPIMAX_TG Time of that fiber P2TG2 * NTRIK_TG Same as NK_TG P2TG2 * XTGT_TP Extrapolated x of UTC track exit from target P2TG2 * YTGT_TP Extrapolated y of UTC track exit from target P2TG2 * ZTGT_TP Extrapolated z of UTC track exit from target P2TG2 * DTGT_TP _Supposed_ to be the x/y distance between (XTGT_TP,YTGT_TP) and the swath-determined exit point, but it's not... P2TG2 * RTDIF_TG Error in path length in the target P2TG2 * EPIMAXK Highest energy pi fiber in close proximity to a K fiber P2TG2 * PHIVTX Smallest "Phase angle" of all pi fibers P2TG2 * DRPMAX Max. dist. of pi fiber from UTC center of curvature P2TG2 * DRPMIN Min. dist. of pi fiber from UTC center of curvature P2TG2 * NKCLUST Number of K clusters P2TG2 * NKCLUST2 Number of K clusters connected to swath P2TG2 * PLN_SW Path length of decay track in target P2TG2 * PLNV_SW Visible path length of decay track in target P2TG2 * X_B4SW Same as XIN P2TG2 * Y_B4SW Same as YIN P2TG2 * IFAIL_KIC "KIC" cut return code P2TG2 * DTK swath: standard deviation of kaon time P2TG2 * DTPI swath: standard deviation of pion tim P2TG3 * NK_TG_S # K fiber CCD pulses saved P2TG3 * N1 # Number of bins saved for each pulse P2TG3 * N2 | P2TG3 * N3 | P2TG3 * N4 | P2TG3 * N5 | P2TG3 * N6 | P2TG3 * N7 | P2TG3 * N8 | P2TG3 * N9 | P2TG3 * N10 | P2TG3 * N11 | P2TG3 * N12 | P2TG3 * N13 | P2TG3 * N14 | P2TG3 * N15 V P2TG3 * CCD1(N1) K fiber CCD pulse shapes P2TG3 * CCD2(N2) | P2TG3 * CCD3(N3) | P2TG3 * CCD4(N4) | P2TG3 * CCD5(N5) | P2TG3 * CCD6(N6) | P2TG3 * CCD7(N7) | P2TG3 * CCD8(N8) | P2TG3 * CCD9(N9) | P2TG3 * CCD10(N10) | P2TG3 * CCD11(N11) | P2TG3 * CCD12(N12) | P2TG3 * CCD13(N13) | P2TG3 * CCD14(N14) | P2TG3 * CCD15(N15) V P2TG3 * CCDPF(NK_TG_S) K fiber CCD pulse unpacking/pulse-finding flags P2TG3 * CCDBIN(NK_TG_S) K fiber CCD pulse starting bin P2TG3 * CCDLOW(NK_TG_S) .TRUE. if low-gain K fiber CCD pulse P2TD * NELVET # Hits found by elveto5.F P2TD * ISEV(NELVET) Severity of these hits P2TD * ISTEV5 ev5.F return code for IMODE = 0 P2TD * ISTEV5M1 ev5.F return code for IMODE = 1 P2TD * T1MT2 End/end pion time difference P2TD * EELEC1 local electron energy (arith. mean of TD PH's) P2TD * EELEC2 global electron energy (geom. mean of TD PH's) P2TD * EELEC2C global electron energy (geom. mean of cal. TD PH's) P2TD * TELEC electron time P2TD * DTELEC end-to-end difference for electron cluster relative to T1MT2 P2TD * PROBTD TD pi probability in stopping counter P2TD * PROBTDN Slightly different TD pi probability in stopping counter P2TD * IFAIL_TDFL tdfool.F return code P2TD * NHEXCT Number of TD channels fit by tdfool.F P2TD * ICODE_TDFL(NHEXCT) tdfool.F return code for each of those channels P2TD * EMUT_TDFL(NHEXCT) Total uncalibrated mu energy for each of those channels P2TD * EMUTC_TDFL(NHEXCT) Total calibrated mu energy for each of those channels P2TD * TMUAV_TDFL(NHEXCT) Average mu time for each of those channels P2TD * DT_TDFL(NHEXCT) End-to-end mu time difference for each of those channels P2TD * DTMU_TDFL(NHEXCT) Av. mu time difference with stopping counter P2TD * CMUEND_TDFL(2,NHEXCT) Double-pulse chisq for each counter (both ends) P2TD * CPIEND_TDFL(2,NHEXCT) Single-pulse chisq for each counter (both ends) P2TD * CMUPI_TDFL(2,NHEXCT) mu/pi chisq ratio for each counter (both ends) P2TD * PROD_TDFL(NHEXCT) mu/pi chisq ratio product for each counter P2TD * NHIT_STHEX number of hits in stopping TD hextant P2TD * ESUM_STHEX total energy of hits in stopping TD hextant P2TD * EMAX_STHEX max. energy hit in stopping TD hextant P2TD * ESTHEX(4) ADC energy in each counter in stopping hextant P2TD * NNOFID # TD channels for which no fiducial pulse was found P2TD * CHNOFID(NNOFID) Channel numbers of TD channels for which no fiducial pulse was found P2TD * TIME_FIDX(288) raw time of TD fiducial in each channel P2TD * IFID_CODEX(288) TD fiducial code in each channel *************************************************************************************** Photon veto mnemonics: RD: Rangestack (RS) BV: Barrel veto BV: Barrel veto liner EC: Endcap EU: Endcap inner upstream ring TG: Target IC: I-counter VC: V-counter CO: Collar CM: Micro-collar P2PV1 * NPVRD RS: # photon veto hits P2PV1 * TPVRD(NPVRD) RS: times of those hits P2PV1 * EPVRD(NPVRD) RS: energies of those hits P2PV1 * ELEMPVRD(NPVRD) RS: module numbers of those hits P2PV1 * EPVRDPR RS: total energy near TRS P2PV1 * TZPVRD(NPVRD) RS: "z" from end-to-end time difference P2PV1 * EZPVRD(NPVRD) RS: "z" from end-to-end energy ratio P2PV1 * PVRDTE1(NPVRD) TD flag pulse diagnostic info. (see fiddec.F) P2PV1 * PVRDTR1(NPVRD) | P2PV1 * PVRDTH1(NPVRD) | P2PV1 * PVRDTF1(NPVRD) | P2PV1 * PVRDTE2(NPVRD) | P2PV1 * PVRDTR2(NPVRD) | P2PV1 * PVRDTH2(NPVRD) | P2PV1 * PVRDTF2(NPVRD) V P2PV2 * NPVBV BV: # photon veto hits P2PV2 * TPVBV(NPVBV) BV: times of those hits P2PV2 * EPVBV(NPVBV) BV: energies of those hits P2PV2 * ELEMPVBV(NPVBV) BV: module numbers of those hits P2PV2 * EPVBVPR BV: total energy near TRS P2PV2 * TZPVBV(NPVBV) BV: "z" from end-to-end time difference P2PV2 * EZPVBV(NPVBV) BV: "z" from end-to-end energy ratio P2PV2 * NPVBL BL: # photon veto hits P2PV2 * TPVBL(NPVBL) BL: times of those hits P2PV2 * EPVBL(NPVBL) BL: energies of those hits P2PV2 * ELEMPVBL(NPVBL) BL: module numbers of those hits P2PV2 * EPVBLPR BL: total energy near TRS P2PV2 * TZPVBL(NPVBL) BL: "z" from end-to-end time difference P2PV2 * EZPVBL(NPVBL) BL: "z" from end-to-end energy ratio P2PV2 * NPVEC EC: # photon veto hits P2PV2 * TPVEC(NPVEC) EC: times of those hits P2PV2 * EPVEC(NPVEC) EC: energies of those hits P2PV2 * HPVEC(NPVEC) EC: CCD pulse heights of those hits P2PV2 * RPVEC(NPVEC) EC: CCD risetimes of those hits P2PV2 * ELEMPVEC(NPVEC) EC: module numbers of those hits P2PV2 * EPVECPR EC: total energy near TRS (Everything but the inner upstream ring) P2PV2 * EPVEUPR EC: total energy near TRS (inner upstream ring) P2PV2 * FPVECHI(NPVEC) EC: .TRUE. if CCD pulse is overflowed P2PV2 * FPVECT0(NPVEC) EC: .TRUE. if T0 calibration wonky for this channel P2PV2 * FPVECSTR(NPVEC) EC: .TRUE. if Timing strobe problem P2PV2 * FPVEC2ND(NPVEC) EC: .TRUE. if "2nd pulse", according to ccd_pulsate.F P2PV2 * FPVECSFT(NPVEC) EC: .TRUE. if Byte count problem P2PV2 * FPVECDNP(NPVEC) EC: .TRUE. if problems with reference pixels P2PV2 * FPVECSTRD(NPVEC) EC: .TRUE. if no EC detector strobe pulse found P2PV2 * EPVECGT EC: total INTIME energy near TRS (obsolete; unused) (Everything but the inner upstream ring) P2PV2 * EPVEUGT EC: total INTIME energy near TRS (obsolete; unused) (inner upstream ring) P2PV3 * NPVIC IC/VC: # photon veto hits P2PV3 * TPVIC(NPVIC) IC/VC: times of those hits P2PV3 * EPVIC(NPVIC) IC/VC: energies of those hits P2PV3 * ELEMPVIC(NPVIC) IC/VC: module numbers of those hits P2PV3 * EPVICPR IC: total energy near TRS P2PV3 * EPVVCPR VC: total energy near TRS P2PV3 * NPVCO CO: # photon veto hits P2PV3 * TPVCO(NPVCO) CO: times of those hits P2PV3 * EPVCO(NPVCO) CO: energies of those hits P2PV3 * ELEMPVCO(NPVCO) CO: module numbers of those hits P2PV3 * EPVCOPR CO: total energy near TRS P2PV3 * NPVCM CM: # photon veto hits P2PV3 * TPVCM(NPVCM) CM: times of those hits P2PV3 * EPVCM(NPVCM) CM: energies of those hits P2PV3 * ELEMPVCM(NPVCM) CM: module numbers of those hits P2PV3 * EPVCMPR CM: total energy near TRS P2PV3 * NPVTG TG: # photon veto hits P2PV3 * TPVTG(NPVTG) TG: times of those hits P2PV3 * EPVTG(NPVTG) TG: energies of those hits P2PV3 * ELEMPVTG(NPVTG) TG: module numbers of those hits P2PV3 * EPVTGPR TG: total energy near TRS P2PV3 * CCDTPV(NPVTG) Same as TPVTG, except from CCD's P2PV3 * CCDEPV(NPVTG) Same as EPVTG, except from CCD's P2PV3 * CCDHPV(NPVTG) Pulse heights P2PV3 * CCDRPV(NPVTG) Pulse rise times P2PV3 * LCCDPV(NPVTG) .TRUE. if low-gain fiber P2PV3 * NPVBS # CCD strobe hits found P2PV3 * TPVBS(NPVBS) times of those hits P2PV3 * HPVBS(NPVBS) pulse heights of those hits P2PV3 * ELEMPVBS(NPVBS) module numbers of those hits P2PV3 * TPVBSTD TD detector strobe time P2PV3 * FPVBSHI(NPVBS) .TRUE. if CCD pulse is overflowed P2PV3 * FPVBST0(NPVBS) .TRUE. if T0 calibration wonky for this channel P2PV3 * FPVBSSTR(NPVBS) .TRUE. if Timing strobe problem P2PV3 * FPVBSSFT(NPVBS) .TRUE. if problems with reference pixels P2PV3 * FPVBSNOTD .TRUE. if TD detector strobe not found "Single-ended" photon veto mnemonics: Read left to right ======> First 1/2 characters Next 2 characters Next 2 characters ======================================================================= N : number SA : Single-end ADC hit ST : Single-end TDC hit E : energy BA : Both-ends ADC hit BT : Both-ends TDC hit T : time NA : No ADC hit NT : No TDC hit S : energy sum EL : module number Continued Next 2 characters Final digit (some categories of RD only) =============================================================== RD : Rangestack 1 : Not in RS track hextant BV : Barrel veto 2 : In RS track hextant E.G. ELSABTRD1 : Module numbers of RD hits with single-end ADC and both-ends TDC, _not_ in the RS track hextant P2PV4 * NSABTRD1 Use handy mnemonic guide to tell you what is what... P2PV4 * NSABTRD2 | P2PV4 * NSASTRD1 | P2PV4 * NSASTRD2 | P2PV4 * ESABTRD1(NSABTRD1) | P2PV4 * ESABTRD2(NSABTRD2) | P2PV4 * ESASTRD1(NSASTRD1) | P2PV4 * ESASTRD2(NSASTRD2) | P2PV4 * TSABTRD1(NSABTRD1) | P2PV4 * TSABTRD2(NSABTRD2) | P2PV4 * TSASTRD1(NSASTRD1) | P2PV4 * TSASTRD2(NSASTRD2) | P2PV4 * SSABTRD1 | P2PV4 * SSABTRD2 | P2PV4 * SSASTRD1 | P2PV4 * SSASTRD2 | P2PV4 * ELSABTRD1(NSABTRD1) | P2PV4 * ELSABTRD2(NSABTRD2) | P2PV4 * ELSASTRD1(NSASTRD1) | P2PV4 * ELSASTRD2(NSASTRD2) | P2PV5 * NSANTRD | P2PV5 * NNABTRD | P2PV5 * NBASTRD1 | P2PV5 * NBASTRD2 | P2PV5 * ESANTRD(NSANTRD) | P2PV5 * EBASTRD1(NBASTRD1) | P2PV5 * EBASTRD2(NBASTRD2) | P2PV5 * TSANTRD(NSANTRD) | P2PV5 * TNABTRD(NNABTRD) | P2PV5 * TBASTRD1(NBASTRD1) | P2PV5 * TBASTRD2(NBASTRD2) | P2PV5 * SBASTRD1 | P2PV5 * SBASTRD2 | P2PV5 * ELSANTRD(NSANTRD) | P2PV5 * ELNABTRD(NNABTRD) | P2PV5 * ELBASTRD1(NBASTRD1) | P2PV5 * ELBASTRD2(NBASTRD2) | P2PV6 * NSABTBV | P2PV6 * NSASTBV | P2PV6 * NSANTBV | P2PV6 * NNABTBV | P2PV6 * NBASTBV | P2PV6 * ESABTBV(NSABTBV) | P2PV6 * ESASTBV(NSASTBV) | P2PV6 * ESANTBV(NSANTBV) | P2PV6 * EBASTBV(NBASTBV) | P2PV6 * TSABTBV(NSABTBV) | P2PV6 * TSASTBV(NSASTBV) | P2PV6 * TNABTBV(NNABTBV) | P2PV6 * TBASTBV(NBASTBV) | P2PV6 * SSABTBV | P2PV6 * SSASTBV | P2PV6 * SBASTBV | P2PV6 * ELSABTBV(NSABTBV) | P2PV6 * ELSASTBV(NSASTBV) | P2PV6 * ELSANTBV(NSANTBV) | P2PV6 * ELNABTBV(NNABTBV) | P2PV6 * ELBASTBV(NBASTBV) V P2PV7 * NISTAT7 # EC CCD channels with missing reference pixels + 1 P2PV7 * MODISTAT7(NISTAT7) Module numbers of those EC channels; # RSSC hits used in trkrng fit Analysis tools Forum: e949.pass1 Date: 2001, Dec 05 From: Joseph Mildenberger Dear Collaborators, Attached is a description and "How to" for the e949 "analysis system" suite of scripts. These scripts allow you to quickly define and and produce anywhere from very simple to very complicated COMIS "cut functions" to analyzed e949 ntuple data. I hope people will at least give it a try, and let me know what they like/don't like about it, and what they would like to see added (or subtracted). The README file is a modified version of instructions provided for the 1998 data analysis; it is possible that some old or obsolete information remains there, in spite of my attempt to purge it of all such things. If you find anything of that nature, or features that do not work as advertised, please let me know so I can fix them. Joe --------------AD4208CC872FABBA439573BF Content-Type: text/plain; charset=us-ascii; name="README" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="README" This file is ~e949/pass2/01/anal/README . Last update: Joe Mildenberger December 05, 2001 "Analysis System" Instructions, etc. ====================================== Following is a description and set of instructions for making use of the pass2 "Analysis System". The system was developed to provide a uniform operating environment for the pnn(1) data analysis, in order to both make the analysis more accessible to the collaboration by making it easier to become involved, and to provide a structure in the form of a common format for background analyses. As well as providing order and uniformity and making the analysis as a whole more transparent, the new structure is designed to facilitate greater reliability and and easier reproducibility of results. Although at the present time, the intended capabilities of the system are still incomplete, enough of it is functional for users to begin trying it out and getting used to how it works. More features are under construction, and will be announced as they are completed. The top directory for the scripts and other associated files is /sitka/home/e949/pass2/01/anal . The setup commands "setup e949 ; setup pass2 01" define an environment variable $PASS2_ANAL to point to this directory. The main script of interest to data analyzers is $PASS2_ANAL/build_func.csh . This script will construct a cut function with any combination of named pnn(1) analysis cuts, for use with either PAW or in a standalone FORTRAN job. As well, it can also be used to construct an NTSKIM job in order to quickly and easily make convenient data sets for specialized background studies. Since the base functions for all of these options are identical, there is no necessity for the user to edit any of the code in order provide specific compatibility with any of these operating modes. The easiest way to explain the presently available features is by way of an example, which anyone can try on his/her own. Suppose I want to produce a cut function that will reproduce the cuts applied to the background sample used fro the photon veto optimization procedure. This data sample is made from the pass2 skim1/4 stream, with the addition of piscat and kinematic cuts, and is restricted to events in the KPI2BOX, as defined in setup_pass1. In my working directory, I would do the following: > echo FUNC_DEF : PSCUT01 KINCUT01 KPI2BOX > phveto_rej.def (The name choice for the ".def" file is entirely arbitrary, but the function-building script requires that it have the ".def" suffix.) > setup pass2 01 > $PASS2_ANAL/build_func.csh phveto_rej comis # for a comis file .OR. > $PASS2_ANAL/build_func.csh phveto_rej fortran # for a fortran executable (* 05/12/01 J.M. *) (* J.M. n.b. The FORTRAN option is not yet available for e949. *) (* But it's not all that it's cracked up to be, anyway. *) Assuming that the defintions for these cuts exist in the appropriate areas, that is all that is necessary to produce the cut function. We now look in more detail at the required function definitions. In order for the desired cut function to be constructed properly, it is necessary that all of the cutnames listed in phveto_rej.def to be found in one of the standard cut definition files: $PASS2_ANAL/def/skim_bits.def $PASS2_ANAL/def/pass1_cuts.def $PASS2_ANAL/def/pass2_cuts.def $PASS2_ANAL/def/custom_cuts.def The first 3 files contain, respectively, the names of the pass2 output skim streams, the names of the cuts appplied by setup_pass1, and the names of the cuts applied by setup_pass2. All of these cuts are "special" in the sense that their pass/fail statuses are recorded as logical bits in the pass2 ntuples. Here are the contents of these files: 1. skim_bits.def # List of meaningful skim bits in 1998 pass2 code. SKIM1 SKIM2 SKIM3 SKIM4 SKIM5 SKIM6 I.e. only 6 output skim streams are defined. 2. pass1_cuts.def # List of pass1 cuts defined for 1998 pass2 code. TRBIT RD_TRK STLAY RSHEX TRKTIM INTIME FITPI UTC RDUTM PDC LAY14 UTC1 RANGE1 TARGET KPI2BOX PRESCALE3 3. pass2_cuts.def # List of pass2 cuts defined for 1998 pass2 code. EPRHICUT EPRLOCUT DIPANG PNNSTOP TGRECON TGCUT RSHEX2 DELCO TDCUT KINCUT PSCUT PVCUT TGPVCUT TDCUT1 KINCUT1 PSCUT1 PVCUT1 TGPVCUT1 TGPVTR RTOT50 PSTAG TGCUT1 PSTAG1 DELCO1 LAYER14 All the other cuts, i.e. all of those defined in cutsom_cuts.def, have to be determined by the stored quantities in the pass2 ntuples. Here is the list of presently defined custom cuts: Start of custom_cuts.def: ######################################################################## # List of custom cuts defined for post-pass2 analysis PVPROB : pvprob.function PVCUT01 : pvcut01.function PVCUTRD : pvcut_rd.function TDFUNC : td_func.function TDFUNC_ORIG : td_func_orig.function PROBKPI2 : probkpi2.function PROBKMU2 : probkmu2.function BAD_RUN_95 : bad_run_95.function BAD_RUN : bad_run.function BAD_STC : bad_stc.function SINGLE_BM_95 : single_bm_sn95.function SINGLE_BM_96 : single_bm_sn96.function SINGLE_BM_97 : single_bm_sn97.function DOUBLE_BM_95 : double_bm_sn95.function DOUBLE_BM_96 : double_bm_sn96.function DOUBLE_BM_97 : double_bm_sn97.function SUMMARY_NT_DUMMY : summary_nt_dummy.comp_func ALL_FUNC : all_func.comp_func ONE_THIRD : mod(event,3).eq.0 TWO_THIRDS : mod(event,3).ne.0 ################################################ # Following functions associated with kincut01 KINCUT01 : kincut01.comp_func FIDUCIAL : fiducial.comp_func RSDEDX : rsdedx.comp_func RNGMOM : rngmom.function TGDEDX : tgdedx.comp_func ICODEL14 : icodel14.function PIGAP : pi_gap.function PRRF : prrf.comp_func TGLIKE : tglike.comp_func TGB4 : tgb4.comp_func UTCQUAL : utc_qual.function EIC : eiccon.function COS3D : cos_3d.function LAYV4 : lay_v4.function ZFRF : zfrf.function ZUTOUT : zut_out.function RSDEDXCL : rsdedx_cl.function RSDEDXMAX : rsdedx_max.function RSLIKE : rs_like.function RNGMOM_NEW3 : rngmom_new3.function RTGHI : rtghi.function ETGHI : etghi.function TGDEDX1 : tgdedx1.function TGDEDX2 : tgdedx2.function PR_RF : prrf1.function PRRFZ1_N : prrfz1_n.function PR_RFZ2 : prrfz2.function PROBZ : prob_z.function PR_RF_AB : pr_rf_ab.function TGLIKE1 : tglike1.function TGLIKE2 : tglike2.function TGDB4 : tgdb4.function TGDB4TIP : tgdb4tip.function TGDVXTIP : tgdvxtip.function TGDVXPI : tgdvxpi.function ################################################ # Following functions associated with pscut01 PSCUT01 : pscut01.comp_func B4BWBH : b4bwbh.comp_func CERENKOV : cerenkov.comp_func TGPATT : tgpatt.comp_func TGENERGY : tgenergy.comp_func TIMING : timing.comp_func PBNRS : pbn_rs.function DELC : delc.function KIC : kic.function TGGEO : tggeo.function B4DEDX : b4dedx.function BWTRS : bwtrs.function B4TRS : b4t_rs.function B4TD : b4td.function CPITRS : cpit_rs.function CPITAIL : cpitail.function CKTRS : ckt_rs.function CKTAIL : cktail.function TGQUALT : tgqualt.function TGZFOOL : tgzfool.function EPITG : epitg.function EPIMAXK : epimax.function TARGF : targf.function DTGTTP : dtgttp.function RTDIF : rtdif.function DRP : drp.function PHIVTX : phivtx1.function PHIVTX2 : phivtx2.function B4EKZ : b4ekz.function TGER : tger.function OPSVETO : opsveto.function TGCCDPF : tgccdpf.function TGEDGE : tgedge.function TIMCON : timcon.function TGCCD : tgccd.function TIC : ticcon.function ################################################ # Following functions associated with tdcut01 TDCUT01 : tdcut01.comp_func IPIFLG : piflg.function ISTEV5M1 : stev5m1.function ELVETO : elveto_new.function TDFOOL : ifail_tdfool.function TDVARNN : tdvarnn.function ################################################# TDDFA1NN : tddfa1nn.function TDDFA1 : tddfa1.function TDCUT1 : tdcut1.function TDVEL : tdvel.function TDLIK2 : tdlik2.function TDLIK3 : tdlik3.function TDDFA2 : tddfa2.function PIMASS : pimass.function EXT_1 : EXT(1) TRBIT_1 : LEV0(1) TRBIT_6 : LEV0(6) TRBIT_9 : LEV0(9) TRBIT_10 : LEV0(10) TRBIT_11 : LEV0(11) RTOT_LE_45 : RTOT.LE.45. LAY_GE_11 : LAY.GE.11 RTOT_GE_31 : RTOT.GE.31. RTOT_GE_33 : RTOT.GE.33. RTOT_LE_42 : RTOT.LE.42. ETOT_GE_109 : ETOT.GE.109. ETOT_GE_115 : ETOT.GE.115. CPINRS_N_GE_5 : CPINRS_N.GE.5 CPITRS_N_TAG : cpitrs_n_tag.fragment SKIM1_NO_TD : skim1_no_td.comb SKIM3_NO_TD : skim3_no_td.comb SKIM4_NO_TD : skim4_no_td.comb SKIM6_NO_TD : skim6_no_td.comb SKIM1_OR_SKIM4 : skim(1).or.skim(4) SKIM2_OR_SKIM5 : skim(2).or.skim(5) SKIM3_OR_SKIM6 : skim(3).or.skim(6) RSHEX2_TIGHT : rshex2_tight.function LAY_LT_21 : LAY.LT.21 KMU2BOX : kmu2box.function PVCUT_ONLINE : .NOT.(EXT(4).OR.EXT(5).OR..NOT.LHEX) SCALERS : get_scalers.function FIX_ALL : fix_all.function IC_FIX : ic_fix.function BOX : box.comp_func EBOX : ebox.function PBOX : pbox.function RBOX : rbox.function ERBOX : erbox.comp_func # kincut8 with no rsdedx, tgdedx, rngmom, lay cuts KINCUT8_MU : kincut8_mu.comp_func FIDUCIAL_NO_LAY : fiducial_no_lay.comp_func # kincut8 with no pion-specific cuts KINCUT8_NOPID : kincut8_nopid.comp_func # kincut8 with no lay cut KINCUT8_NO_LAY : kincut8_no_lay.comp_func # kincut8 with no rsdedx, tgdedx, rngmom, lay cuts KINCUT8_MU_COS3DOFF : kincut8_mu_cos3doff.comp_func FIDUCIAL_NO_LAY_COS3DOFF : fiducial_no_lay_cos3doff.comp_func # kincut8 with no cos3d restriction KINCUT8_COS3DOFF : kincut8_cos3doff.comp_func FIDUCIAL_COS3DOFF : fiducial_cos3doff.comp_func # kincut8 with no lay cut, no RS dE/dx cuts KINCUT8_PHVETO : kincut8_phveto.comp_func # kincut8 with no rngmom cut KINCUT8_NORP : kincut8_norp.comp_func # kincut8 with no TG cuts KINCUT8_NOTG : kincut8_notg.comp_func # Yet another grouping that may be useful KIN_PID_PI : kin_pid_pi.comp_func # Slight shift in ETOT centroid from 104 to 105 MeV KPI2BOX_MOD : kpi2box_mod.function PSCUT5_NOCK : pscut5_nock.comp_func ICBIT : ext(3) B4ABM2_PITAG : b4abm2.le.1.3 TMUAV1_LE_95 : tmuav1.le.95. ANYSKIM : anyskim.function ZSCAT : zscat.function ACCINT : accint.function REPDEV : repdev.function FIX_97 : fix_97.function BHTRS : bht_rs.function ######################################################################## End of custom_cuts.def the first cut in the example is named PSCUT01, and we see in custom_cuts.def then entry PSCUT01 : pscut01.comp_func This means that PSCUT01 is a "composite" or "compound" function composed of several or even many more basic cut functions. In order to find out what these are, we examine the file $PASS2_ANAL/func/pscut01.comp_func, which is reproducted below: B4BWBH : b4bwbh.comp_func CERENKOV : cerenkov.comp_func TGPATT : tgpatt.comp_func TGENERGY : tgenergy.comp_func TIMING : timing.comp_func PBNRS : pbn_rs.function EIC : eiccon.function DELC : delc.function KIC : kic.function TGGEO : tggeo.function From this, we see that pscut01.comp_func is itself composed of a combination of several other "composite" functions, and several "simple" functions. (N.B. The present division of the these complex cuts into the different categories was done without a large amount of deep thought. It is quite conceivable that we may decide on different divisions as the analysis progresses, if the utility of the present categories is found to be insufficient. Or, it may be found that a certain categorization scheme is more useful for some studies, while a different scheme is more useful for others. One nice thing about this "atomization" is that this categorization can be quickly and easily modified simply by creating new definition files.) There is no limit to the number of layers of "composite" functions, since the function construction algorithm is recursive. In practice, however, it would be unlikely that we would have more than 2 "layers" of such function definitions. The main reason for "atomizing" the background rejection functions in this manner is so new cut functions with various "pieces" either turned off or reversed (_Any_ cut can be reversed in your .def file simply by putting a "-" in front of it, e.g. -PSCUT5) can be easily and reliably constructed from the component parts with no need for the used to do his/her own "commenting out" of various bits and pieces of code, which can lead to problems from introducing bugs, or from forgetting that this or that cut has been de-activated. in a particular version of the function. Taking just one of these, cerenkov.comp_func, as an example, we see that $PASS2_ANAL/func/cerenkov.comp_func contains CPITRS : cpit_rs.function CPITAIL : cpitail.function CKTRS : ckt_rs.function CKTAIL : cktail.function Since we have finally resolved the definition to the level of "simple" functions, we can examine the features of these. Looking at $PASS2_ANAL/func/cpitail.function, we see: Start of cpitail.function ######################################################################## function cpitail(dummy_argument) implicit none real cpitail , dummy_argument real dummy real cpitail_val c include statement goes here real cpitimebm,cpitimebm2,cpitimers,cpitimers2 integer cpinumbm,cpinumbm2,cpinumrs,cpinumrs2 real cpitimebm_n,cpitimebm2_n,cpitimers_n,cpitimers2_n integer cpinumbm_n,cpinumrs_n real tcut real timebm(2), timers(2) real timebm_b4, timebm2_b4, timebm_rs, timebm2_rs integer nbm(2), nrs(2), nbm_b4, nbm_rs real analyze_cpi_mod,analyze_cpi_n_mod C.. CPITAIL cpitail = 0. dummy = analyze_cpi_mod(timebm,nbm,timers,nrs) dummy = analyze_cpi_n_mod(timebm_b4,timebm2_b4,nbm_b4, & timebm_rs,timebm2_rs,nbm_rs) cpitimebm = min(30.,max(-30.,timebm(1) - b4str)) cpitimebm2 = min(30.,max(-30.,timebm(2) - b4str)) cpinumbm = min(14,max(0,nbm(1))) cpinumbm2 = min(14,max(0,nbm(2))) cpitimers = min(30.,max(-30.,timers(1))) cpitimers2 = min(30.,max(-30.,timers(2))) cpinumrs = min(14,max(0,nrs(1))) cpinumrs2 = min(14,max(0,nrs(2))) cpitimebm_n = min(30.,max(-30.,timebm_b4 - b4str)) cpitimebm2_n = min(30.,max(-30.,timebm2_b4 - b4str)) cpinumbm_n = min(14,max(0,nbm_b4)) cpitimers_n = min(30.,max(-30.,timebm_rs - trs)) cpitimers2_n = min(30.,max(-30.,timebm2_rs - trs)) cpinumrs_n = min(14,max(0,nbm_rs)) * if(run.lt.29000) then * if(abs(cpitimers2).lt.2.0.and.cpinumrs2.gt.4) return * if(abs(cpitimers2_n).lt.2.0.and.cpinumrs_n.gt.4) return * else * if(abs(cpitimers2).lt.2.0.and.cpinumrs2.gt.4) return * endif tcut = 999.0 if (cpinumrs2.gt.4) then if (run.lt.35550) then ! 95-97 if (abs(cpitimers2/2.0).lt.tcut) & tcut = abs(cpitimers2/2.0) else ! 98 if (abs((cpitimers2+0.45)/2.0).lt.tcut) ! 3 sigmas & tcut = abs((cpitimers2+0.45)/2.0) endif endif if (run.lt.29000) then if (cpinumrs_n.gt.4) then if (abs(cpitimers2_n/2.0).lt.tcut) & tcut = abs(cpitimers2_n/2.0) endif endif CPITAIL_VAL = tcut if (CPITAIL_VAL.lt.1.0) return cpitail = 1. return end c needs : analyze_cpi_mod c needs : analyze_cpi_n_mod ################################################################### End of cpitail.function These functions look (more or less) like common COMIS or FORTRAN files, with a few embedded strings to allow the function-building script to do its job properly. In particular, we see near the top: function cpitail(dummy_argument) implicit none real cpitail , dummy_argument real dummy real cpitail_val c include statement goes here The line "c include statement goes here" is replaced by the script with the appropriate common block declaration for the comis file include /home/e949/pass2/01/anal/include/pass2nt.inc or the FORTRAN version include /home/e949/pass2/01/ntskim/source/ntskim_cmn.list FUNCTION DEFINITIONS USED IN THE ANALYSIS MUST COMPLY WITH THIS FORMAT, meaning that the IMPLICIT NONE statement and the common block "place holder" statement MUST be included in the function. All local variables MUST be declared (This includes functions!) . In addition, any dependent functions and/or subroutines, i.e. analysis routines referenced DIRECTLY by the function must be listed at the bottom as per the above example: return end c needs : analyze_cpi_mod c needs : analyze_cpi_n_mod In this way, all of the necessary dependent functions, and only the necessary ones, will be included in the user-defined cut function. In order to make the automated construction of composite functions work properly, an addition stipulation is that all simple functions MUST return either a "1" (PASS) or a "0" (FAIL). This means that some existing functions have been placed in a "wrapper" in order to force the PASS/FAIL criterion into this format, e.g. real function rs_like c implicit statement goes here c include statement goes here real rslike rs_like = 0. if(rslike(0.).gt.9.0.or.rslike(0.).le.0.) return rs_like = 1. return end c needs : rslike The other types of cut conditions listed are the literal strings (no suffix), and the "bit combination" (.comb). An example of the former is LAY_LT_21 . This cut requirement is interpreted as a .TRUE. condition of the LOGICAL expression LAY.LT.21 . An example of the latter is SKIM1_NO_TD which uses the definition in $PASS2_ANAL/def/skim1_no_td.comb : TGRECON RSHEX2 PSCUT TGCUT TGPVCUT -PRESCALE3 As the name suggests, this is the stream definition for pass2 skim stream 1, but with the TDCUT requirement removed. With the successful construction of the cut function, the file phveto_ref.f is created in the user's working directory. An inspection of the this file reveals the following: As mentioned previously, cuts with definitions in pass1_cuts.def and pass2_cuts.def have their results stored in an array of logical bits, cut(100), in the pass2 ntuple. Thus, it is necessary to determine the cut offsets for the various requested pass1/pass2 cut names. In the past, one had to get these offsets by looking at the analysis logfiles, and they sometimes changed when the analysis code was re-run and/or re-compiled, or differed between monitor and pnn data samples, resulting in analysis mistakes if these differences were not accounted for. Now, the cut names are stored in the ntuple itself, so that this kind of mistake can be eliminated. A special section of code is required used in the initialization section of the cut function to determine the cut array offsets. In this case, that section looks like this: if(lfirst) then lfirst = .false. num_mycuts = num_mycuts + 1 mycuts(num_mycuts) = 'KPI2BOX' do i = 1,num_mycuts ioffcut(i) = 0 write(6,*) ' Looking for cut offset for ',mycuts(i) cname = mycuts(i) ind1 = index(cname,' ') - 1 if (cname(1:1).eq.'-') then write(6,*) ' Reversing ',cname(2:ind1) mycuts(i) = cname(2:ind1) bar(i) = .true. else bar(i) = .false. endif do j=1,ncuts if (cutnames(j).eq.mycuts(i)) then cname = mycuts(i) ind1 = index(cname,' ') - 1 write(6,*) cname(1:ind1),' cut is #',j ioffcut(i) = j endif enddo if(ioffcut(i).eq.0) then write(6,*) ' Error reading cut array. Quitting...' return endif enddo endif Another feature is a built-in print flag (logical variable LPRINT) that can be turned on to print out diagnostic information about which cut(s) are causing events to fail, e.g.: do i=1,num_mycuts if (((.not.bar(i)).and.( cut(ioffcut(i)))) .or. + (( bar(i)).and.(.not.cut(ioffcut(i)))) ) then if(lprint) then if(bar(i)) then write(6,*) ' Failed cut -',mycuts(i) else write(6,*) ' Failed cut ',mycuts(i) endif endif return endif enddo IF(pscut01(0.).lt.0.5) THEN if(lprint) write(6,*) 'Failed PSCUT01' RETURN ENDIF IF(kincut01(0.).lt.0.5) THEN if(lprint) write(6,*) 'Failed KINCUT01' RETURN ENDIF Finally, at the end is the complete list of all of the dependent routines needed to run this COMIS file with PAW. Becuae of the "atomization" of the background cut functions, there are many of them!! However, you, the user, no longer need to keep track of the exhaustive list of required functions. To avoid cluttering up your working directory, the dependent functions are placed in a special subdirectory. In addition, any calibration data or other parameters that these functions need that is read in externally is now all stored in a central location, so the user no longer needs to carry around his/her own copies of these files. INCLUDE '/home/joseph/junk/myfunc_dir/pscut5.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4bwbh.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4dedx.f' INCLUDE '/home/joseph/junk/myfunc_dir/bwtrs.f' INCLUDE '/home/joseph/junk/myfunc_dir/bht_rs.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4t_rs.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4td.f' INCLUDE '/home/joseph/junk/myfunc_dir/cerenkov.f' INCLUDE '/home/joseph/junk/myfunc_dir/cpit_rs.f' INCLUDE '/home/joseph/junk/myfunc_dir/cpitail.f' INCLUDE '/home/joseph/junk/myfunc_dir/analyze_cpi_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/analyze_cpi_n_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/ckt_rs.f' INCLUDE '/home/joseph/junk/myfunc_dir/cktail.f' INCLUDE '/home/joseph/junk/myfunc_dir/analyze_ck_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/analyze_ck_n_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgpatt.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgqualt.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgzfool.f' INCLUDE '/home/joseph/junk/myfunc_dir/epitg.f' INCLUDE '/home/joseph/junk/myfunc_dir/epimax.f' INCLUDE '/home/joseph/junk/myfunc_dir/targf.f' INCLUDE '/home/joseph/junk/myfunc_dir/dtgttp.f' INCLUDE '/home/joseph/junk/myfunc_dir/rtdif.f' INCLUDE '/home/joseph/junk/myfunc_dir/drp.f' INCLUDE '/home/joseph/junk/myfunc_dir/phivtx1.f' INCLUDE '/home/joseph/junk/myfunc_dir/phivtx2.f' INCLUDE '/home/joseph/junk/myfunc_dir/phivtx_new.f' INCLUDE '/home/joseph/junk/myfunc_dir/read_geom.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgenergy.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4ekz.f' INCLUDE '/home/joseph/junk/myfunc_dir/beam_like.f' INCLUDE '/home/joseph/junk/myfunc_dir/divdif.f' INCLUDE '/home/joseph/junk/myfunc_dir/b4ekz_ic.f' INCLUDE '/home/joseph/junk/myfunc_dir/tger.f' INCLUDE '/home/joseph/junk/myfunc_dir/opsveto.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgccdpf.f' INCLUDE '/home/joseph/junk/myfunc_dir/ttccd_dpfind.f' INCLUDE '/home/joseph/junk/myfunc_dir/ccd_pulse_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/ccd_pulsate_mod.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgedge.f' INCLUDE '/home/joseph/junk/myfunc_dir/timing.f' INCLUDE '/home/joseph/junk/myfunc_dir/timcon.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgccd.f' INCLUDE '/home/joseph/junk/myfunc_dir/ticcon.f' INCLUDE '/home/joseph/junk/myfunc_dir/pbn_rs.f' INCLUDE '/home/joseph/junk/myfunc_dir/eiccon.f' INCLUDE '/home/joseph/junk/myfunc_dir/delc.f' INCLUDE '/home/joseph/junk/myfunc_dir/kic.f' INCLUDE '/home/joseph/junk/myfunc_dir/tggeo.f' INCLUDE '/home/joseph/junk/myfunc_dir/dbgeo_tgic.f' INCLUDE '/home/joseph/junk/myfunc_dir/kincut8.f' INCLUDE '/home/joseph/junk/myfunc_dir/fiducial.f' INCLUDE '/home/joseph/junk/myfunc_dir/cos_3d.f' INCLUDE '/home/joseph/junk/myfunc_dir/lay_v4.f' INCLUDE '/home/joseph/junk/myfunc_dir/zfrf.f' INCLUDE '/home/joseph/junk/myfunc_dir/zut_out.f' INCLUDE '/home/joseph/junk/myfunc_dir/rsdedx.f' INCLUDE '/home/joseph/junk/myfunc_dir/rsdedx_cl.f' INCLUDE '/home/joseph/junk/myfunc_dir/rsdedx_max.f' INCLUDE '/home/joseph/junk/myfunc_dir/rs_like.f' INCLUDE '/home/joseph/junk/myfunc_dir/rslike.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdedx.f' INCLUDE '/home/joseph/junk/myfunc_dir/rtghi.f' INCLUDE '/home/joseph/junk/myfunc_dir/etghi.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdedx1.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdedx2.f' INCLUDE '/home/joseph/junk/myfunc_dir/prrf.f' INCLUDE '/home/joseph/junk/myfunc_dir/prrf1.f' INCLUDE '/home/joseph/junk/myfunc_dir/prrfz2.f' INCLUDE '/home/joseph/junk/myfunc_dir/rfz2.f' INCLUDE '/home/joseph/junk/myfunc_dir/prob_z.f' INCLUDE '/home/joseph/junk/myfunc_dir/probz.f' INCLUDE '/home/joseph/junk/myfunc_dir/pr_rf_ab.f' INCLUDE '/home/joseph/junk/myfunc_dir/tglike.f' INCLUDE '/home/joseph/junk/myfunc_dir/tglike1.f' INCLUDE '/home/joseph/junk/myfunc_dir/tglike2.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgb4.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdb4.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdb4tip.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdvxtip.f' INCLUDE '/home/joseph/junk/myfunc_dir/tgdvxpi.f' INCLUDE '/home/joseph/junk/myfunc_dir/rngmom.f' INCLUDE '/home/joseph/junk/myfunc_dir/rngmom_new3.f' INCLUDE '/home/joseph/junk/myfunc_dir/rngmom95.f' INCLUDE '/home/joseph/junk/myfunc_dir/rngmom96.f' INCLUDE '/home/joseph/junk/myfunc_dir/rngmom97.f' INCLUDE '/home/joseph/junk/myfunc_dir/linint.f' INCLUDE '/home/joseph/junk/myfunc_dir/icodel14.f' INCLUDE '/home/joseph/junk/myfunc_dir/pi_gap.f' INCLUDE '/home/joseph/junk/myfunc_dir/pigap.f' INCLUDE '/home/joseph/junk/myfunc_dir/trkpos_nt.f' INCLUDE '/home/joseph/junk/myfunc_dir/utc_qual.f' INCLUDE '/home/joseph/junk/myfunc_dir/utcqual3.f' INCLUDE '/home/joseph/junk/myfunc_dir/utcqual_xy96.f' INCLUDE '/home/joseph/junk/myfunc_dir/utcqual_xy97.f' "Standard Cut Packages" Now Available ======================================= All of the complete major cut packages from the recent 1995-97 analaysis have now been de- and re-assembled, and (slightly) tested to verify that they produce sensible output within the new analysis framework. Since some of these cuts do a fari bit of post-pass2 number crunching, it can be a bit slow to run through many thousands of ntuple records. Nonetheless, all of the pieces are now in place to reproduce the 1995-97 background estimates. (At the time of this writing we processed only the 1995 "TRIUMF" portion of processed data...) Here are the labels to reference these cuts in your personal ".def" files: KINCUT PSCUT TDCUT PVCUT Using Endspill Ntuples with Event Ntuples =========================================== One of the features of the pass2 production code is that the the complete set scaler records is now stored in separate "endspill" ntuples, rather than keeping a a few select scaler variables in the main event ntuples. There are several advantages to this new scheme: 1. Used along with a duplicate endspill record trapping routine (analogous to dupev) these ntuples will now become the primary source of information for measuring the integrated KB_LIVE values. Re-evaluations of KB_LIVE can be made quickly and easily from these ntuples in the case of, for example, the bad_run list having been modified at some later stage of the analysis. As well, the entire machinery of "scaler correction records", previously used to properly account for spills being split up among many files as was done during data taking for 1995 and early 1996, can now be completely bypassed. 2. In the previous production runs, there was no checking to ensure that the scaler information stored in the event ntuple actually belonged with the particular event records. Since it was a known "feature" that endspill records were quite frequently out of sequence on the data tapes, studies involving rate-dependent effects were subject to an unmeasured level of mistakenly assigned scaler values. In the new scheme, the correct scaler reocrd is assured of being found for every event, assuming it ever existed in the original data file to begin with. 3. Rather than a few selected varaibles, the entire scaler array and measured B-field value is saved for every spill. This will allow (if desired) a much more detailed study of rate-dependent processes than was previously possible. Here is how to access the scaler ntuple information in a job that analyses event ntuples. First, include the keyword SCALERS in your .def file when building your analysis cut function. This will cause the routine $PASS2_ANAL/func/get_scalers.function to be included in your analysis function, and also cause the necessary machinery to access any of the scaler variables to be placed in your top-level cut routine. In order to maintain backward compatibility with previous analyses, the set of scaler variables stored in the old ntuples is extracted automatically from the full scaler array, and copied to variables with the same names as were used in the previous analyses. If you want to use any of the other scaler variables, you will need to make a slight modification to your top-level function. For example, if your .def file is simply "FUNC_DEF : SCALERS", the top-level routine will contain the following code in the initialization section: if(lfirst) then lfirst = .false. scstat = get_scalers(cfile,splrec,run,splno) nscal = nscal + 1 ascal(nscal) = 'KB_L' do i = 1,nscal iscal(i) = 0 write(6,*) ' Looking for scaler offset for ',ascal(i) do j=1,num_names if (scaler_names(j).eq.ascal(i)) then cname = ascal(i) ind1 = index(cname,' ') - 1 write(6,*) cname(1:ind1),' scaler is at offset #',j iscal(i) = j endif enddo if(iscal(i).eq.0) then write(6,*) ' Error reading scaler name array. Quitting...' status = -1. endif enddo endif The first (dummy) call to get_scalers is used so that the array of scaler names can be obtained to find the array offsets for the scaler variables of interest. A "seed" name ("KB_L") has been supplied to show you how to extract any other scaler variables of interest to you. To add more variables, simply duplicate the 2 lines nscal = nscal + 1 ascal(nscal) = 'KB_L' ! Replace with your favorite scaler variable and modify the text string. Consult the tail end of a pass2 analysis log file for the complete list of scaler labels. Then for each consecutive scaler variable you extract (i=1,2,3...nscal) the relevant values will be found in the array elements scalers(iscal(i)). N.b. In order to use get_scalers with paw, you MUST access the input ntuple files via a "chain" command, rather than an "h/fil" command. This is because get_scalers needs to know the name of the event ntuple file in order to find the corresponding scaler ntuple file. To do this, it reads the name from the character variable cfile stored in pass2nt.inc. But this variable is only filled when the "chain" command is used to open the input file. Data Registry and Automated Script Generation =============================================== $PASS2_ANAL/build_func.csh now automatically generates either a kumac or a .csh run script to loop over selected data with your custom-built cut function. To facilitate this, the various analysis data sets on disk are catalogued in a "data registry" ($PASS2_ANAL/data/data_location.list) which links mnemomic keywords with the physical locations of the data sets. The file presently contains the following entries: KM21_D_NT : /data4/e949/pass2/km21 /data3/e949/pass2/km21 KM21N_D_NT : /data4/e949/pass2/km21n /data3/e949/pass2/km21n KP22_D_NT : /data4/e949/pass2/kp22 /data3/e949/pass2/kp22 KP22N_D_NT : /data4/e949/pass2/kp22n /data3/e949/pass2/kp22n KP21_D_NT : /data4/e949/pass2/kp21 /data3/e949/pass2/kp21 KBEAM_D_NT : /data4/e949/pass2/kbeam /data3/e949/pass2/kbeam PISCAT_D_NT : /data4/e949/pass2/piscat /data3/e949/pass2/piscat PNN1OR2_D_NT : /data4/e949/pass2/pnn1or /data3/e949/pass2/pnn1or PNNL0_D_NT : /data4/e949/pass2/pnnl0 /data3/e949/pass2/pnnl0 All one needs to do to use this feature is to make an additional one-line entry in the .def file, e.g. echo FUNC_DEF : PSCUT01 KINCUT01 KPI2BOX > phveto_rej.def echo USE_DATA : KP22_D_NT KP22N_D_NT >> phveto_rej.def A run script in either .csh or .kumac format is now generated automatically when one runs $PASS2_ANAL/build_func.csh. In addition, the inclusion of the USE_DATA directive results in the creation of a either a simple file list (fortran), or a .kumac file with the appropriate "nt/loop" commands for the selected data set. The created run script is called run_phveto_rej.csh (fortran) or run_phveto_rej.kumac (comis). For the .kumac file, all one needs to do is to edit run_phveto_rej.kumac to book the desired histograms, and phveto_rej.f to fill them. The .kumac file is run by starting paw, and typing paw> exec run_phveto_rej In both cases, the filled histograms are automatically dumped to an hbook histogram file after all of the input files have been read. This is the end of the first installment of information about the analysis system. As mentioned, I will provide more information as new features are added, or as requested by users. I encourage you to try out the presently available features, and let me know if things don't work as advertised, or if any parts of the explanation are unclear, or if there are other features you think would be of general use. Joe