StRoot: RTS/EventTracker/eventTrackerLib.cxx Source File

00001 // Switch between l3t and ftf in sl3.h!!!
00002 
00003 #ifndef TRG_VERSION
00004 #define TRG_VERSION 0x32
00005 #endif
00006 
00007 #include <unistd.h>
00008 #include <string.h>
00009 #include <setjmp.h>
00010 #include <daqFormats.h>
00011 #include "l3CoordinateTransformer.h"
00012 #include <rts.h>
00013 #include "rtsLog.h"
00014 #include "FtfSl3.h"
00015 #ifdef OLD_DAQ_READER
00016 #include <evpReader.hh>
00017 #else /* OLD_DAQ_READER */
00018 #include <DAQ_READER/daqReader.h>
00019 #endif /* OLD_DAQ_READER */
00020 #include "gl3Event.h"
00021 #include "eventTrackerLib.hh"
00022 #include <DAQ_L3/daq_l3.h>
00023 
00024 
00025 #ifdef OLD_DAQ_READER
00026 int EventTracker::trackEvent(evpReader *evp, char *mem, L3_P *l3p, int max_size)
00027 #else /* OLD_DAQ_READER */
00028 int EventTracker::trackEvent(daqReader *rdr, char *mem, L3_P *l3p, int max_size)
00029 #endif /* OLD_DAQ_READER */
00030 {
00031   DATAP *datap = (DATAP *)mem;
00032   // Build L3_p
00033   int ret=0;
00034   char *buff = (char *)l3p;
00035 
00036   // First do tracking...
00037   L3_GTD *gtd = (L3_GTD *)(buff + sizeof(L3_P));
00038 #ifdef OLD_DAQ_READER
00039   ret = trackTPC(evp, mem, gtd, max_size - sizeof(L3_P));
00040 #else /* OLD_DAQ_READER */
00041   ret = trackTPC(rdr, mem, gtd, max_size - sizeof(L3_P));
00042 #endif /* OLD_DAQ_READER */
00043  
00044   LOG(DBG, "gtd: nHits=%d", gtd->nHits);
00045 
00046    // Now build the L3_P bank...
00047   memset(l3p, 0, sizeof(L3_P));  
00048 
00049   memcpy(l3p->bh.bank_type, CHAR_L3_P, 8);
00050   l3p->bh.length = sizeof(L3_P) / 4;
00051   l3p->bh.bank_id = 0;
00052   l3p->bh.format_ver = DAQ_RAW_FORMAT_VERSION;
00053   l3p->bh.byte_order = DAQ_RAW_FORMAT_ORDER;
00054   l3p->bh.format_number = 0;
00055   l3p->bh.token = 0;
00056   l3p->bh.w9 = DAQ_RAW_FORMAT_WORD9;
00057   l3p->bh.crc = 0;
00058 
00059   // Pick up trigger info from datap if possible...
00060   l3p->len = (sizeof(L3_P) + gtd->bh.length * 4) / 4;
00061   
00062   // do we need to swap datap?
00063   int sdatap = (datap->bh.byte_order == DAQ_RAW_FORMAT_ORDER) ? 0 : 1;
00064 
00065   
00066   l3p->time = qswap32(sdatap, datap->time);
00067   l3p->gl3Id = 0;
00068   l3p->trg_word = qswap32(sdatap, datap->trg_word);
00069   l3p->trg_in_word = qswap32(sdatap, datap->trg_in_word);
00070 
00071   // Currently only fill tracks...
00072   l3p->tracks.off = sizeof(L3_P) / 4;
00073   l3p->tracks.len = gtd->bh.length;
00074 
00075   return ret;
00076 }
00077 
00078 #ifdef OLD_DAQ_READER
00079 int EventTracker::trackTPC(evpReader *rdr, char *mem, L3_GTD *gtd, int max_size)
00080 #else /* OLD_DAQ_READER */
00081 int EventTracker::trackTPC(daqReader *rdr, char *mem, L3_GTD *gtd, int max_size)
00082 #endif /* OLD_DAQ_READER */
00083 {
00084   // bField != 1000 means use it, 1000 means take from file...
00085   gl3->readFromEvpReader(rdr, mem, defaultBField, bField, GL3_READ_TPC_TRACKS);
00086 
00087   return gl3Event_to_GTD(gtd, max_size);
00088 }
00089 
00090 
00091 int EventTracker::gl3Event_to_GTD(L3_GTD *gtd,  u_int max_size)
00092 {
00093   // Build GTD...
00094   memcpy(gtd->bh.bank_type, CHAR_L3_GTD, 8);
00095   gtd->bh.bank_id = 1;
00096   gtd->bh.format_ver = DAQ_RAW_FORMAT_VERSION;
00097   gtd->bh.byte_order = DAQ_RAW_FORMAT_ORDER;
00098   gtd->bh.format_number = 0;
00099   gtd->bh.token = 0;
00100   gtd->bh.w9 = DAQ_RAW_FORMAT_WORD9;
00101   gtd->bh.crc = 0;
00102   
00103   // GTD structure already includes one track
00104   gtd->bh.length = (sizeof(L3_GTD) + (gl3->getNTracks() - 1) * sizeof(global_track))/4;
00105   
00106   if(gtd->bh.length * 4 > max_size) {
00107     LOG(ERR, "GDT length needs to be %d bytes, but max buffers size only %d bytes",
00108         gtd->bh.length * 4, max_size,0,0,0);
00109     
00110     return -1;
00111   }
00112   
00113   // This stuff need to figure out later.  
00114   gtd->nHits = 0;
00115   
00116   gtd->xVert = gl3->getVertex().Getx();
00117   gtd->yVert = gl3->getVertex().Gety();
00118   gtd->zVert = gl3->getVertex().Getz();
00119   gtd->nTracks = gl3->getNTracks();
00120 
00121   for(uint i=0;i<gtd->nTracks;i++) {
00122 
00123     global_track gtrack;
00124     gl3Track *gl3track = gl3->getTrack(i);
00125 
00126     gtrack.id = gl3track->id;
00127     gtrack.flag = gl3track->flag;                                // Primaries flag=1, Secondaries flag=0
00128     gtrack.innerMostRow = gl3track->innerMostRow;
00129     gtrack.outerMostRow = gl3track->outerMostRow;
00130 
00131     gtrack.nHits = gl3track->nHits;                  // Number of points assigned to that track
00132     gtd->nHits += gtrack.nHits;
00133 
00134     //gtrack->reserved ; 
00135     gtrack.ndedx = gl3track->nDedx;                  // nr of clusters contributing to the dedx value
00136     gtrack.q = gl3track->q;              // charge
00137     gtrack.chi2[0] = gl3track->chi2[0];         // chi squared of the momentum fit
00138     gtrack.chi2[1] = gl3track->chi2[1];
00139     gtrack.dedx = gl3track->dedx;                    // dE/dx information
00140     gtrack.pt = gl3track->pt;                  // pt (transverse momentum) at (r,phi,z)
00141     gtrack.phi0 = gl3track->phi0;                    // azimuthal angle of the first point
00142     gtrack.psi = gl3track->psi;   // azimuthal angle of the momentum at (r,..
00143     gtrack.r0 = gl3track->r0;                                    // r (in cyl. coord.) for the first point
00144     gtrack.tanl = gl3track->tanl;                                   // tg of the dip angle at (r,phi,z)
00145     gtrack.z0 = gl3track->z0;                                    // z coordinate of the first point
00146     gtrack.length = gl3track->length;
00147     gtrack.dpt = gl3track->dpt;
00148     gtrack.dpsi = gl3track->dpsi;
00149     gtrack.dz0 = gl3track->dz0;
00150     gtrack.dtanl = gl3track->dtanl;
00151 
00152     
00153     memcpy(&gtd->track[i], &gtrack, sizeof(global_track));
00154   }  
00155 
00156   return 0;
00157 }
00158 
00159 void EventTracker::dumpGTD(L3_GTD *gtd)
00160 {
00161   if(memcmp(gtd->bh.bank_type, "L3_GTD", 5) != 0) {
00162     printf("Not a L3_GTD Bank: %s\n",gtd->bh.bank_type);
00163     return;
00164   }
00165 
00166   printf("Computed:   Tracks: %5d:    Vertex: (%6.2f/%6.2f/%6.2f)\n",
00167          gtd->nTracks,gtd->xVert, gtd->yVert, gtd->zVert);
00168   
00169   for(u_int i=0;i<gtd->nTracks;i++) {
00170     global_track *track = &(gtd->track[i]);
00171     
00172     
00173     printf("%5d: pt=%5.3f z0=%7.2f q=%2d nHits=%2d ndedx=%2d ",
00174            i, track->pt, track->z0, track->q, 
00175            track->nHits, track->ndedx); 
00176     
00177     printf("flag=0x%04x iRow=%2d oRow=%2d\n",
00178            track->flag, track->innerMostRow, 
00179            track->outerMostRow); 
00180   }
00181 }
00182 
00183 
00184 int EventTracker::copyl3_t(l3_t &l3, L3_P *l3p)
00185 {
00186   int len = l3p->bh.length;
00187 
00188   l3.max_channels = 1280000 ;
00189   l3.channels = 0 ;
00190   l3.mode = 1 ;
00191 
00192   // Tonko, zero this out and make non-sensical in case of further
00193   // problems down the road
00194   l3.tracks_num = 0 ;
00195   l3.cluster_num = 0 ;
00196   l3.xVertex = -1000.0 ;
00197   l3.yVertex = -1000.0 ;
00198   l3.zVertex = -1000.0 ;
00199 
00200   LOG(DBG,"L3_P bytes %d",len,0,0,0) ;
00201 
00202   if(checkBank(l3p->bh.bank_type,"L3_P") != 0) {
00203     return -1 ;
00204   }
00205 
00206 
00207   if(l3p->tracks.len && l3p->tracks.off){
00208     struct L3_GTD* l3gtd = 
00209       (struct L3_GTD*)((char*)l3p + l2h32(l3p->tracks.off)*4) ;
00210 
00211     // Tonko, sanity check
00212     if(checkBank(l3gtd->bh.bank_type,"L3_GTD") < 0) {
00213       return -1 ;
00214     }
00215 
00216     LOG(NOTE, "l3gtd->nTracks=%d nHits=%d", l2h32(l3gtd->nTracks), l2h32(l3gtd->nHits));
00217     l3.tracks_num = l2h32(l3gtd->nTracks);
00218     l3.cluster_num = l2h32(l3gtd->nHits);
00219     l3.xVertex = l2hfloat(l3gtd->xVert);
00220     l3.yVertex = l2hfloat(l3gtd->yVert);
00221     l3.zVertex = l2hfloat(l3gtd->zVert);
00222 
00223     // Tonko, sanity check
00224     if(l3.tracks_num >= L3_MAX_NR_TRACKS) {
00225       LOG(ERR,"L3 track number %d > %d!",l3.tracks_num,L3_MAX_NR_TRACKS ,0,0,0) ;
00226       return -1 ;
00227     }
00228 
00229 
00230     for (unsigned int i=0; i<l3.tracks_num; i++) {
00231       global_track *tr = &(l3gtd->track[i]);
00232 
00233       l3.track[i].id = l2h32(tr->id);
00234 
00235 #ifndef UNIX_LITTLE_ENIDAN
00236       l3.track[i].flag         = tr->flag;
00237       l3.track[i].innerMostRow = tr->innerMostRow;
00238       l3.track[i].outerMostRow = tr->outerMostRow;
00239 
00240       l3.track[i].nHits = tr->nHits;
00241       l3.track[i].ndedx = tr->ndedx;
00242       l3.track[i].q     = tr->q;
00243 #else
00244       l3.track[i].flag = ( ((unsigned short)tr->innerMostRow) |
00245                            ((unsigned short)tr->outerMostRow)<<8);
00246       l3.track[i].innerMostRow = (char)( tr->flag & 0x00ff );
00247       l3.track[i].outerMostRow = (char)((tr->flag & 0xff00)>>8);
00248 
00249       l3.track[i].nHits    = (unsigned char)tr->q;
00250       l3.track[i].reserved = (char)tr->ndedx;
00251       l3.track[i].ndedx    = (unsigned char)tr->reserved;
00252       l3.track[i].q        = (char)tr->nHits;
00253 #endif
00254       l3.track[i].chi2[0] = l2hfloat(tr->chi2[0]);
00255       l3.track[i].chi2[1] = l2hfloat(tr->chi2[1]);
00256       l3.track[i].dedx    = l2hfloat(tr->dedx);
00257       l3.track[i].pt      = l2hfloat(tr->pt);
00258       l3.track[i].phi0    = l2hfloat(tr->phi0);
00259       l3.track[i].psi     = l2hfloat(tr->psi);
00260       l3.track[i].r0      = l2hfloat(tr->r0);
00261       l3.track[i].tanl    = l2hfloat(tr->tanl);
00262       l3.track[i].z0      = l2hfloat(tr->z0);
00263       l3.track[i].length  = l2hfloat(tr->length);
00264       l3.track[i].dpt     = l2hfloat(tr->dpt);
00265       l3.track[i].dpsi    = l2hfloat(tr->dpsi);
00266       l3.track[i].dz0     = l2hfloat(tr->dz0);
00267       l3.track[i].dtanl   = l2hfloat(tr->dtanl);
00268 
00269     }
00270               
00271 
00272   }
00273 
00274 
00275 #ifdef SHOW_DEBUG_INFO
00276 
00277 #ifdef UNIX_LITTLE_ENDIAN
00278   printf("Running on LITTLE endian machine\n");
00279 #else
00280   printf("Running on BIG endian machine\n");
00281 #endif
00282 
00283   printf("\nVertex: (%6.2f/%6.2f/%6.2f)\n",
00284          l3.xVertex, l3.yVertex, l3.zVertex);
00285 
00286   printf("Tracks: %5d   Clusters %7d\n",
00287          l3.tracks_num, l3.cluster_num);
00288         
00289   for (unsigned int i=0; i<l3.tracks_num; i++) {
00290     printf("%5d: pt=%5.3f z0=%7.2f q=%2d nHits=%2d ndedx=%2d ",
00291            i, l3.track[i].pt, l3.track[i].z0, l3.track[i].q, 
00292            l3.track[i].nHits, l3.track[i].ndedx); 
00293 
00294     printf("flag=0x%04x iRow=%2d oRow=%2d\n",
00295            l3.track[i].flag, l3.track[i].innerMostRow, 
00296            l3.track[i].outerMostRow); 
00297   }
00298 
00299 #endif
00300 
00301   return len ;
00302 
00303 }