StRoot: RTS/src/DAQ_TPC/tpc_FCFReader.cxx Source File

00001 #include <string.h>
00002 #include <stdio.h>
00003 
00004 #include <daqFormats.h>
00005 #include <rtsSystems.h>
00006 #include <rtsLog.h>
00007 
00008 #include <fcfClass.hh>
00009 
00010 //#include <evpSupport.h>
00011 //#include <tpcReader.h>
00012 #include <TPC/padfinder.h>
00013 #include <TPC/rowlen.h>
00014 #include <adcLogTable.h>
00015 
00016 #include "daq_tpc.h"
00017 
00018 /************************************************/
00019 // This is not a READER!
00020 // 
00021 // It calculates clusters from the filled tpc 
00022 // structure...
00023 //
00024 /************************************************/
00025 
00026 #define FCF_MAX_CLUSTERS 6000
00027 
00028 // Assume that tpc raw structure is alread filled
00029 //
00030 //  t0corr   --> int   t0[46][242], for this sector
00031 //  gainCorr --> u_int gain[46][242], for this sector
00032 // 
00033 int daq_tpc::fcfReader(int sector, int *t0c, u_int *gainc, tpc_t *tpc)          // from zero
00034 {
00035   fcfClass *fcf = NULL;
00036   fcfAfterburner *fcf_after = NULL;
00037 
00038   int row, p, t;
00039   u_short tb;
00040 
00041   u_int adcOff[183] ;
00042   u_short cppOff[183] ;
00043   u_short startFlags[183];
00044   u_int output[2*FCF_MAX_CLUSTERS];
00045   u_int hits = 0;
00046   u_int *fcf_ptrs[3];
00047   int t0[242];
00048   u_int gain[242];
00049   
00050   memset(tpc->cl_counts, 0, sizeof(tpc->cl_counts));
00051   memset(tpc->cl, 0, sizeof(tpc->cl));
00052   tpc->has_clusters = 1;
00053 
00054   if(tpc->mode != 0) return -1;   // don't do for pedestals...
00055 
00056   fcf = new fcfClass(TPC_ID, NULL);
00057   fcf_after = new fcfAfterburner();
00058   
00059   for(int r=0;r<45;r++) {
00060     int have_data = 0;
00061     row = r+1;
00062 
00063     // Padrow adc data stored in "adc"
00064     u_char adc[182][512];
00065 
00066     memset(adc, 0, sizeof(adc));
00067     int adcs=0;
00068     for(p=0;p<182;p++) {
00069       for(t=0;t<tpc->counts[r][p];t++) {
00070         u_char val;
00071         tb = tpc->timebin[r][p][t];
00072         val = tpc->adc[r][p][t];
00073 
00074         adc[p][tb] = val;       
00075 
00076 //      if((sector == 1)) {
00077 //        printf("cl_raw  %d %d %d %d %d\n",sector,r+1,p+1,tb,val) ;
00078 //      }
00079         
00080         if(val) {
00081           have_data = 1;
00082           adcs++;
00083         }
00084       }
00085     }
00086 
00087     // Padrow cpp stored in "cpp"
00088     u_short cpp[182][32*2];
00089 
00090     int seqs = 0;
00091 
00092     memset(cpp, 0xff, sizeof(cpp));
00093     for(p=0;p<182;p++) {
00094       int started, cou, max_seq;
00095 
00096       started = cou = max_seq = 0;
00097 
00098       for(tb=0;tb<512;tb++) {
00099         
00100         if(adc[p][tb] > 0) {
00101           if(started) continue;
00102 
00103           // start a new cluster pointer
00104           started = 1;
00105 
00106           if(cou <= 60)          // more than 31 clusters?
00107             cpp[p][cou++] = tb;
00108           else 
00109             LOG(NOTE, "Cou is begger %d pad %d tb %d",cou,p,tb);
00110         }
00111         
00112         if(started && (adc[p][tb] == 0)) {  // finish cluster
00113           
00114           seqs++;
00115 
00116           if(cou <= 61) 
00117             cpp[p][cou++] = tb-1;
00118           else 
00119             LOG(NOTE, "Cou is bigger %d pad %d tb %d",cou,p,tb);
00120 
00121 
00122           //test
00123 //        if(r==0) {
00124 //          LOG(NOTE, "r=%d p=%d t1=%d t2=%d:",r,p,cpp[p][cou-2],cpp[p][cou-1]);
00125 //          for(int ii=cpp[p][cou-2]; ii <= cpp[p][cou-1];ii++) {
00126 //            LOG(NOTE, "        adc[%d][%d]=%d",p,ii,adc[p][ii]);
00127 //          }
00128 //        }
00129           //
00130 
00131           started = 0;
00132         }
00133       }
00134 
00135       // done last tb, stop if neccessary
00136       if(started) {
00137         seqs++;
00138         cpp[p][cou++] = tb-1;
00139       }
00140 
00141       //      LOG(NOTE, "r=%d p=%d seq=%d",r,p,cou);
00142       started = 0;
00143     }
00144 
00145     
00146 
00147     //    LOG(NOTE, "adcs=%d seqs=%d",adcs, seqs);
00148 
00149     // Point to correct locations...
00150     for(int i=0;i<182;i++) {
00151       adcOff[i+1] = (char *)(&adc[i][0]) - (char *)(&adc[0][0]);
00152       cppOff[i+1] = (char *)(&cpp[i][0]) - (char *)(&cpp[0][0]) ;
00153     }
00154 
00155 //     for(int i=0;i<182;i++) {
00156 //       u_short *pp = (u_short *)(((u_char *)cpp) + cppOff[i+1]);
00157 //       if((sector == 1)) {
00158 //      while(*pp != 0xffff) {
00159 //        printf("cpp  %d %d %d %d %d\n",sector,r+1,i+1,*pp,1) ;
00160 //        pp++;
00161 //        printf("cpp  %d %d %d %d %d\n",sector,r+1,i+1,*pp,1) ;
00162 //        pp++;
00163 //      }
00164 //       }
00165 //     }
00166 
00167     
00168     /*    
00169     if(r == 0) {
00170       for(p=0;p<182;p++) {
00171         u_char *x = ((u_char *)cpp) + cppOff[p+1];
00172         
00173         for(tb=0;tb<512;tb++) {
00174           
00175           LOG(NOTE, "cpp[%d][%d] = %d = cppOff = %d",
00176               p,tb,cpp[p][tb], *(x+tb));
00177 
00178           if(cpp[p][tb] == 0xff) break;
00179         }  
00180       }
00181     }
00182     */
00183 
00184 
00185     fcf->adcOff = adcOff;
00186     fcf->cppOff = cppOff;
00187     
00188     fcf->timebinLo = 0;
00189     fcf->timebinHi = 400;
00190     fcf->chargeMin = 40;
00191     fcf->set8to10(log8to10_table);
00192     
00193 
00194     if(t0c) {
00195       for(int i=0;i<182;i++) t0[i+1] = t0c[46*r + i];
00196     }
00197     else {
00198       for(int i=0;i<182;i++) t0[i+1] = 0;
00199     }
00200 
00201     if(gainc) {
00202       for(int i=0;i<182;i++) gain[i+1] = gainc[46*r + i];
00203     }
00204     else {
00205       for(int i=0;i<182;i++) gain[i+1] = 64;
00206     }
00207 
00208     fcf->t0Corr = t0;
00209     fcf->gainCorr = gain;
00210 
00211     fcf->maxClusters = FCF_MAX_CLUSTERS;
00212 
00213     fcf->simIn = NULL;
00214     fcf->simOut = NULL;
00215 
00216     fcf_after->setVerbose(false);
00217 
00218     fcf->startFlags = startFlags;
00219     
00220     memset(startFlags, 0, sizeof(startFlags));
00221 
00222     memset(output, 0, sizeof(output));
00223     u_int *out = output;
00224  
00225     memset(fcf_ptrs, 0, sizeof(fcf_ptrs));
00226 
00227     fcf->row = r+1;
00228 
00229     for(int mz=0;mz<3;mz++) {
00230       
00231       if(padfinder[r][mz].rdo == 0) continue;
00232 
00233       fcf->padStart = padfinder[r][mz].minpad;
00234       fcf->padStop = padfinder[r][mz].maxpad;
00235 
00236      
00237       if(fcf->padStart == 1) startFlags[fcf->padStart] |= FCF_ROW_EDGE;
00238       else(startFlags[fcf->padStart]) |= FCF_BROKEN_EDGE;
00239 
00240       if(tpc_rowlen[r+1] == fcf->padStop)
00241         startFlags[fcf->padStop] |= FCF_ROW_EDGE;
00242       else
00243         startFlags[fcf->padStop] |= FCF_BROKEN_EDGE;
00244 
00245    
00246       
00247       u_int words = fcf->finder((u_char *)adc, 
00248                                 (u_short *)cpp,
00249                                 (u_int *)out);
00250 
00251       //      LOG(NOTE, "c(%d)%d-%d padrow %d words=%d", mz, fcf->padStart, fcf->padStop, r,words);
00252  
00253       
00254       fcf_ptrs[mz] = out; 
00255 
00256       if(words != (*(out+1))*2 + 2) {
00257         LOG(ERR, "Words should match %d vs %d (%d)",
00258             words, (*(out+1))*2 + 2, *(out+1));
00259       }      
00260 
00261       out += words;
00262 
00263     } // mz loop
00264 
00265     // Can burn this row...
00266     
00267 //     for(int ii=0;ii<3;ii++) {
00268 //       uint *x = fcf_ptrs[ii];
00269 //       if(!x) continue;
00270 //       int row = *x;
00271 //       x++;
00272 //       int ncl = *x;
00273 //       x++;
00274 
00275  
00276 //       while(ncl) {
00277 //      mzCentroid *cent=(mzCentroid *)x;
00278 //      if(sector == 1)
00279 //        {
00280 //          printf("nrcl: %d %d %d %d %d %d %d %d\n",
00281 //                 sector,r+1,row,ii,cent->x,cent->t,cent->flags,cent->charge);
00282 //        }
00283 //      ncl--;
00284 //      x++;
00285 //      x++;
00286 //       }
00287 //     }
00288     
00289     fcf_after->burn(fcf_ptrs);
00290 
00291     int ccou=0;
00292     fcfHit h;
00293     tpc_cl *cld;
00294     
00295     while(fcf_after->next(&h)) {
00296       cld = &tpc->cl[r][ccou];
00297       ccou++;
00298       
00299       
00300       cld->p = (double)h.pad/64.0 + 0.5;
00301       cld->t = (double)h.tm/64.0 + 0.5;
00302 
00303       //      LOG(WARN,"  pad=%lf %lf",cld->p, cld->t);
00304       cld->charge = h.c;
00305       cld->flags = h.f;
00306       cld->t1 = h.t1;
00307       cld->t2 = h.t2;
00308       cld->p1 = h.p1;
00309       cld->p2 = h.p2;
00310 
00311     }
00312 
00313     hits += ccou;
00314     tpc->cl_counts[r] = ccou;
00315   }    // row loop
00316 
00317   delete fcf_after;
00318   delete fcf;
00319 
00320   return hits;
00321 }