RTS/EventTracker/gl3Event.cxx
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include "gl3Event.h"
00014 #include <rtsLog.h>
00015 #include "gl3Histo.h"
00016 #ifdef OLD_DAQ_READER
00017 #include <evpReader.hh>
00018 #else
00019 #include <DAQ_READER/daqReader.h>
00020 #endif
00021 #include "FtfSl3.h"
00022 #ifndef OLD_DAQ_READER
00023
00024 #include <DAQ_READER/daq_dta.h>
00025 #include <DAQ_TPC/daq_tpc.h>
00026 #include <DAQ_TPX/daq_tpx.h>
00027 #include <DAQ_SC/daq_sc.h>
00028
00029 tpc_t *pTPC=NULL;
00030
00031 #endif
00032
00033
00034
00035
00036 #ifdef OLD_DAQ_READER
00037 int gl3Event::readFromEvpReader(evpReader *evp,
00038 #else
00039 int gl3Event::readFromEvpReader(daqReader *rdr,
00040 #endif
00041 char *mem,
00042 float defaultbField,
00043 float bField,
00044 int what)
00045 {
00046 #ifndef OLD_DAQ_READER
00047 daq_dta *dd;
00048
00049 #endif
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062 LOG(DBG, "Reader from EVP Reader: evt=%d token=%d",rdr->seq,rdr->token);
00063
00064 resetEvent();
00065 nHits = 0;
00066
00067 LOG(DBG, "Check magnetic field");
00068
00069
00070 if(bField == 1000) {
00071 bField = defaultbField;
00072
00073 #ifdef OLD_DAQ_READER
00074 int ret = scReader(mem);
00075 if(ret >= 0) {
00076 if(sc.valid) bField = sc.mag_field;
00077 #else
00078 dd = rdr->det("sc")->get("legacy");
00079
00080 if(dd) {
00081 dd->iterate();
00082 sc_t *sc = (sc_t *)dd->Void;
00083 if(sc->valid) bField = sc->mag_field;
00084 #endif
00085 }
00086 }
00087
00088 if(fabs(bField) < .1) bField = .1;
00089
00090 LOG(NOTE, "bField set to %f",bField,0,0,0,0);
00091
00092 setBField(bField);
00093
00094
00095 coordinateTransformer->Set_parameters_by_hand(0.581, 200.668, 201.138 );
00096 coordinateTransformer->LoadTPCLookupTable("/RTS/conf/L3/map.bin");
00097
00098 FtfSl3 *tracker = new FtfSl3(coordinateTransformer);
00099
00100 tracker->setup();
00101 tracker->para.bField = fabs(bField);
00102
00103
00104 tracker->para.bFieldPolarity = (bField>0) ? 1 : -1;
00105
00106
00108 tracker->setXyError(.12) ;
00109 tracker->setZError(.24) ;
00110
00111 tracker->para.ptMinHelixFit = 0.;
00112 tracker->para.maxChi2Primary = 0.;
00113
00114 tracker->para.trackChi2Cut = 10 ;
00115 tracker->para.hitChi2Cut = 50 ;
00116 tracker->para.goodHitChi2 = 20 ;
00118
00119
00120 tracker->reset();
00121
00122
00123 L3_SECTP *sectp = NULL;
00124
00125 if(what & GL3_READ_TPC_TRACKS) {
00126 sectp = (L3_SECTP *)malloc(szSECP_max);
00127 }
00128
00129 int i;
00130 int ret;
00131 for(i=0;i<24;i++) {
00132 if(what & GL3_READ_TPC_TRACKS) {
00133 if((i%2) == 0) {
00134 tracker->nHits = 0;
00135 tracker->setTrackingAngles(i+1);
00136 }
00137 }
00138
00139 LOG(DBG, "READ TPC data for sector %d (0x%x)",i+1,rdr);
00140
00141
00142 #ifdef OLD_DAQ_READER
00143 ret = tpcReader(mem, i);
00144 if(ret < 0) {
00145 LOG(WARN, "No data for sector %d",i+1,0,0,0,0);
00146 #else
00147 dd = rdr->det("tpx")->get("legacy",i+1);
00148 if(dd) {
00149 LOG(NOTE, "There is tpx data...");
00150 dd->iterate();
00151 pTPC = (tpc_t *)dd->Void;
00152 }
00153 else {
00154 LOG(NOTE, "No tpx data for sector %d check for TPC",i);
00155
00156 dd = rdr->det("tpc")->get("legacy",i+1);
00157 if(dd) {
00158 dd->iterate();
00159 pTPC = (tpc_t *)dd->Void;
00160
00161
00162
00164
00165
00166
00167
00168
00169 int cl_found = 0;
00170 for(int pr=0;pr<45;pr++) {
00171 cl_found += pTPC->cl_counts[pr];
00172 }
00173
00174 LOG(NOTE, "Found tpc data for sector %d... %d clusters found",i,cl_found);
00175 }
00176 else {
00177 pTPC = NULL;
00178 }
00179 }
00180
00181 if(!pTPC) {
00182 LOG(WARN, "No data for TPC sector %d",i+1,0,0,0,0);
00183 #endif
00184 continue;
00185 }
00186
00187
00188 #ifdef OLD_DAQ_READER
00189 if(!tpc.has_clusters) {
00190
00191
00192 int ncl_recount = fcfReader(i);
00193 if (ncl_recount) {
00194
00195 }
00196 #else
00197 if(!pTPC->has_clusters) {
00198 LOG(WARN, "TPC sector %d has no clusters",i);
00199 continue;
00200 #endif
00201 }
00202
00203
00204 if(what & GL3_READ_TPC_CLUSTERS) {
00205
00206 LOG(DBG, "Reading clusters");
00207 readClustersFromEvpReader(i+1);
00208
00209 int nnn=0;
00210 for(int i=0;i<45;i++) {
00211 #ifdef OLD_DAQ_READER
00212 nnn += tpc.cl_counts[i];
00213 #else
00214 nnn += pTPC->cl_counts[i];
00215 #endif
00216 }
00217 LOG(DBG, "clusters done %d",nnn);
00218 }
00219
00220
00221 if(what & GL3_READ_TPC_TRACKS) {
00222 LOG(DBG, "Tracking...");
00223 tracker->readSectorFromEvpReader(i+1);
00224
00225
00226 if((i%2) == 1) {
00227 tracker->processSector();
00228 tracker->fillTracks(szSECP_max, (char *)sectp, 0);
00229
00230 LOG(DBG, "SECP size = %d",sectp->bh.length*4 + sectp->banks[0].len*4);
00231
00232 int n = readSectorTracks((char *)sectp);
00233
00234
00235 if(n < 0) {
00236 LOG(WARN, "Error reading tracker: sector %d\n",i,0,0,0,0);
00237 continue;
00238 }
00239 }
00240 }
00241 }
00242
00243
00244 if(what & GL3_READ_TPC_TRACKS) {
00245
00246 finalizeReconstruction();
00247 free(sectp);
00248 }
00249
00250
00251
00252 #ifdef OLD_DAQ_READER
00253 emc.readFromEvpReader(evp, mem);
00254 #else
00255 emc.readFromEvpReader(rdr, mem);
00256 #endif
00257
00258 delete tracker;
00259 return 0;
00260 }
00261
00262
00263
00264
00265 void gl3Event::readClustersFromEvpReader(int sector)
00266 {
00267 #ifdef OLD_DAQ_READER
00268 if(!tpc.has_clusters) return;
00269 #else
00270
00271 LOG(DBG, "have clusters? %d",pTPC->has_clusters);
00272 if(!pTPC->has_clusters) return;
00273 #endif
00274
00275 for(int r=0;r<45;r++) {
00276 #ifdef OLD_DAQ_READER
00277 for(int j=0;j<tpc.cl_counts[r];j++) {
00278 tpc_cl *c = &tpc.cl[r][j];
00279 #else
00280 for(int j=0;j<pTPC->cl_counts[r];j++) {
00281 tpc_cl *c = &pTPC->cl[r][j];
00282 #endif
00283
00284 gl3Hit *gl3c = &hit[nHits];
00285 nHits++;
00286
00287 l3_cluster sl3c;
00288 sl3c.pad = (int)((c->p - 0.5) * 64);
00289 sl3c.time = (int)((c->t - 0.5) * 64);
00290 sl3c.charge = c->charge;
00291 sl3c.flags = c->flags;
00292 sl3c.padrow = r;
00293 sl3c.RB_MZ = 0;
00294
00295
00296
00297
00298
00299 gl3c->set(coordinateTransformer, sector, &sl3c);
00300
00301
00302
00303
00304
00305
00306
00307 }
00308 }
00309 }
00310
00311
00312
00313
00314 gl3Event::gl3Event( l3CoordinateTransformer* inTrans,
00315 l3EmcCalibration* inBemcCalib,
00316 l3EmcCalibration* inEemcCalib,
00317 int mxHits, int mxTracks)
00318 : emc(inBemcCalib, inEemcCalib)
00319 {
00320 hit = NULL;
00321 track = NULL;
00322 busy = 0;
00323
00324 trackContainer = 0;
00325 trackIndex = 0;
00326 hitProcessing = 0;
00327 maxSectorNForTrackMerging = 1000000;
00328 coordinateTransformer = inTrans;
00329
00330 setup( mxHits, mxTracks );
00331 resetEvent();
00332 };
00333
00334
00335 gl3Event::~gl3Event( )
00336 {
00337 if ( hit != 0 ) delete[] hit ;
00338 if ( track != 0 ) delete[] track;
00339 if ( trackContainer != 0 ) delete[] trackContainer;
00340 if ( trackIndex != 0 ) delete[] trackIndex ;
00341 };
00342
00343
00344
00345
00346
00347
00348
00349 gl3Track* gl3Event::getTrack ( int n ) {
00350 if ( n < 0 || n > nTracks ) {
00351 fprintf ( stderr, " %d track index out of range \n", n );
00352 return NULL;
00353 }
00354 return &(track[n]);
00355 }
00356
00357
00358 gl3Hit* gl3Event::getHit ( int n ) {
00359 if ( n < 0 || n > nHits ) {
00360 fprintf ( stderr, " %d hit index out of range \n", n );
00361 return NULL;
00362 }
00363 return &(hit[n]);
00364 }
00365
00366 gl3Sector* gl3Event::getSector ( int n ) {
00367 if ( n < 0 || n > nSectors ) {
00368 fprintf ( stderr, " %d sector index out of range \n", n );
00369 return NULL;
00370 }
00371 return &(sectorInfo[n]);
00372 }
00373
00374
00375 int gl3Event::getTrgCmd()
00376 {
00377
00378 return -1;
00379 };
00380
00381 int gl3Event::getTrgWord()
00382 {
00383 return trgData.triggerWord;
00384 };
00385
00386 int gl3Event::getZDC(int n)
00387 {
00388 return trgData.ZDC[n];
00389 };
00390
00391 int gl3Event::getCTB(int n)
00392 {
00393 return trgData.CTB[n];
00394 };
00395
00396 double gl3Event::getZDCVertex()
00397 {
00398 return ((double)(trgData.ZDC[9] - trgData.ZDC[8]) + 21.3) * 3.3;
00399 };
00400
00401
00402
00403
00404
00405 unsigned int gl3Event::getBXingLo()
00406 {
00407 return trgData.bunchXing_lo;
00408 }
00409
00410 unsigned int gl3Event::getBXingHi()
00411 {
00412 return trgData.bunchXing_hi;
00413 }
00414
00415 unsigned long long gl3Event::getBXing()
00416 {
00417 unsigned long long bx_hi_long = trgData.bunchXing_hi;
00418 unsigned long long bx_lo_long = trgData.bunchXing_lo;
00419
00420 return (bx_hi_long << 32) | bx_lo_long;
00421 };
00422
00423
00424
00425
00426
00427
00428
00429 void gl3Event::addTracks ( short sector, int nTrk, local_track* localTrack ) {
00430
00431 gl3Track* lTrack = &(track[nTracks]) ;
00432 local_track *trk = localTrack ;
00433 int indexStore = -1 ;
00434
00435 int idTrack ;
00436 for ( int i = 0 ; i < nTrk ; i++ ) {
00437 lTrack->set ( sector, trk ) ;
00438 lTrack->id = sector * 1000 + abs(trk->id) ;
00439 lTrack->para = ¶ ;
00440 lTrack->sector = sector ;
00441 idTrack = trk->id ;
00442
00443
00444
00445
00446 if ( hitProcessing ) {
00447 indexStore = -1 ;
00448 if ( abs(idTrack) < maxTracksSector )
00449 indexStore = (sector-1)*maxTracksSector + abs(idTrack) ;
00450 else {
00451 LOG(ERR, " gl3Event::addTracks: max number of tracks per Sector reached %d reached", idTrack ,0,0,0,0) ;
00452 }
00453 }
00454
00455
00456
00457 gl3Track* fatterTrack = 0 ;
00458 if ( maxSectorNForTrackMerging > nTrk && idTrack < 0 ) {
00459
00460 fatterTrack = lTrack->merge ( trackContainer ) ;
00461 if ( fatterTrack ) {
00462 if ( hitProcessing && indexStore > 0 ) {
00463 trackIndex[indexStore] =
00464 ((char *)fatterTrack - (char *)track )/sizeof(gl3Track)+1;
00465 }
00466 trk++ ;
00467 nMergedTracks++ ;
00468 continue ;
00469 }
00470 nMergableTracks++ ;
00471 }
00472
00473
00474 if ( hitProcessing && indexStore > 0 )
00475 trackIndex[indexStore] = nTracks + 1;
00476
00477
00478 lTrack++ ;
00479 nTracks++ ;
00480 trk++ ;
00481 if ( nTracks+1 >= maxTracks ) {
00482 LOG(ERR," gl3Event::addTracks: max number of tracks %d reached, sector: %i nrSectorTracks: %i", maxTracks, sector, nTrk ,0,0) ;
00483 nTracks-- ;
00484 lTrack--;
00485 break;
00486 }
00487 }
00488 }
00489
00490
00491
00492
00493
00494
00495 int gl3Event::fillTracks ( int maxBytes, char* buffer, unsigned int token ){
00496
00497
00498
00499 int nBytesNeeded = sizeof(L3_GTD) + (nTracks-1) * sizeof(global_track) ;
00500 if ( nBytesNeeded > maxBytes ) {
00501 LOG(ERR, " gl3Event::writeTracks: %d bytes needed less than max = %d \n",
00502 nBytesNeeded, maxBytes ,0,0,0) ;
00503 return 0 ;
00504 }
00505
00506 L3_GTD* head = (L3_GTD *)buffer ;
00507
00508 head->nHits = nHits;
00509 head->xVert = vertex.Getx();
00510 head->yVert = vertex.Gety();
00511 head->zVert = vertex.Getz();
00512
00513
00514 memcpy(head->bh.bank_type,CHAR_L3_GTD,8);
00515 head->bh.bank_id = 1;
00516 head->bh.format_ver = DAQ_RAW_FORMAT_VERSION ;
00517 head->bh.byte_order = DAQ_RAW_FORMAT_ORDER ;
00518 head->bh.format_number = 0;
00519 head->bh.token = token;
00520 head->bh.w9 = DAQ_RAW_FORMAT_WORD9;
00521 head->bh.crc = 0;
00522 head->bh.length = (sizeof(struct L3_GTD)
00523 + (nTracks-1) * sizeof(struct global_track))/4 ;
00524
00525
00526
00527
00528
00529 global_track* oTrack = (global_track *)head->track ;
00530 int counter = 0 ;
00531 for ( int i = 0 ; i < nTracks ; i++ ) {
00532 if ( fabs(track[i].z0) > 205 ) {
00533
00534 nBadTracks++ ;
00535 continue ;
00536 }
00537 oTrack->id = track[i].id ;
00538 oTrack->flag = track[i].flag ;
00539 oTrack->innerMostRow = track[i].innerMostRow ;
00540 oTrack->outerMostRow = track[i].outerMostRow ;
00541 oTrack->nHits = track[i].nHits ;
00542 oTrack->ndedx = track[i].nDedx ;
00543 oTrack->q = track[i].q ;
00544 oTrack->chi2[0] = track[i].chi2[0] ;
00545 oTrack->chi2[1] = track[i].chi2[1] ;
00546 oTrack->dedx = track[i].dedx ;
00547 oTrack->pt = track[i].pt ;
00548 oTrack->phi0 = track[i].phi0 ;
00549 oTrack->r0 = track[i].r0 ;
00550 oTrack->z0 = track[i].z0 ;
00551 oTrack->psi = track[i].psi ;
00552 oTrack->tanl = track[i].tanl ;
00553 oTrack->length = track[i].length ;
00554 oTrack->dpt = track[i].dpt ;
00555 oTrack->dpsi = track[i].dpsi ;
00556 oTrack->dz0 = track[i].dz0 ;
00557 oTrack->dtanl = track[i].dtanl ;
00558 oTrack++ ;
00559 counter++ ;
00560 }
00561 head->nTracks = counter ;
00562
00563
00564
00565 return ((char *)oTrack-buffer) ;
00566 }
00567
00568
00569
00570
00571
00572
00573 int gl3Event::readL3Data( L3_P* header )
00574 {
00575
00576 char* buffer = (char *)header;
00577
00578
00579 int length, offset ;
00580 char* trackPointer ;
00581 char* hitPointer ;
00582
00583 resetEvent ( );
00584 int i ;
00585 L3_SECP* sectorP ;
00586 for ( i = 0 ; i < nSectors ; i++ ) {
00587 length = header->sector[i].len ;
00588
00589 if ( length==0 ) continue ;
00590
00591 offset = 4 * header->sector[i].off ;
00592 sectorP = (L3_SECP *)&(buffer[offset]);
00593
00594 trackPointer = (char *)sectorP + sectorP->trackp.off * 4 ;
00595
00596
00597 int nSectorTracks = 0;
00598 if (sectorP->trackp.off) {
00599 nSectorTracks = readSectorTracks ( trackPointer ) ;
00600
00601 if ( nSectorTracks < 0 ) {
00602 LOG(ERR, "gl3Event:readEvent: error reading tracks, sector %d", i+1,0,0,0,0);
00603 return -1 ;
00604 }
00605 }
00606
00607 if ( hitProcessing && sectorP->sl3clusterp.off ) {
00608 hitPointer = (char *)sectorP + sectorP->sl3clusterp.off * 4 ;
00609 readSectorHits ( hitPointer, nSectorTracks ) ;
00610 }
00611
00612 }
00613
00614 if(header->bh.format_number>=5 && header->trig.len){
00615
00616
00617 trgData.readL3P(header);
00618
00619 }
00620
00621
00622 if( header->bh.format_number>=7 ){
00623
00624 emc.readRawData(header);
00625 } else {
00626
00627
00628 }
00629 #ifdef EVENTDISPLAY
00630
00631
00632
00633
00634
00635 double radius ;
00636
00637 for ( int i = 0 ; i < nTracks ; i++ ) {
00638
00639 radius = coordinateTransformer->
00640 GetRadialDistanceAtRow(track[i].innerMostRow-1) ;
00641
00642 track[i].updateToRadius ( radius ) ;
00643
00644
00645
00646 if ( fabs(track[i].z0) > 205 ) track[i].updateToRadius ( radius+5. ) ;
00647 if ( fabs(track[i].z0) > 205 ) {
00648 LOG(ERR, "gl3Event:: problem after extrapolation id %d z0 %f",
00649 track[i].id, track[i].z0 ,0,0,0) ;
00650 }
00651 }
00652 #endif
00653
00654
00655
00656 busy = 1 ;
00657
00658 return 0 ;
00659 }
00660
00661
00662
00663
00664
00665 int gl3Event::finalizeReconstruction()
00666 {
00667
00668
00669 if (vertexFinder & 0x01)
00670 makeVertex();
00671
00672
00673
00674 if ((vertexFinder & 0x02) && lmv) {
00675
00676 lmv->makeVertex(this);
00677 Ftf3DHit vtx = lmv->getVertex();
00678
00679 lmVertex.Setx(vtx.x);
00680 lmVertex.Sety(vtx.y);
00681 lmVertex.Setz(vtx.z);
00682 }
00683
00684
00685 Ftf3DHit vertex_ftf;
00686 vertex_ftf.x = vertex.Getx();
00687 vertex_ftf.y = vertex.Gety();
00688 vertex_ftf.z = vertex.Getz();
00689
00690
00691 for (int i=0 ; i<getNTracks() ; i++) {
00692 getTrack(i)->setDca(vertex_ftf);
00693 }
00694
00695
00696 return 0;
00697 }
00698
00699
00700
00701
00702
00703
00704 int gl3Event::readSectorHits ( char* buffer, int nSectorTracks ){
00705 L3_SECCD* head = (L3_SECCD *)buffer ;
00706
00707
00708
00709 if ( !coordinateTransformer ) {
00710 LOG(ERR, "gl3Event::readSectorHits: there is not Coordinate Transformer",0,0,0,0,0);
00711 return 0 ;
00712 }
00713
00714
00715
00716
00717
00718 if ( strncmp(head->bh.bank_type,CHAR_L3_SECCD,8) ) {
00719 LOG(ERR, "gl3Event::readSectorHits: wrong bank type %s",
00720 head->bh.bank_type,0,0,0,0 ) ;
00721 LOG(ERR, " correct bank type would be %s", CHAR_L3_SECCD,0,0,0,0 ) ;
00722 return 0 ;
00723 }
00724 int sector = head->bh.bank_id;
00725 int nSectorHits = head->nrClusters_in_sector ;
00726
00727
00728
00729
00730 if ( nHits + nSectorHits > maxHits ) {
00731 LOG(ERR, "gl3Event:readSectorHits: not enough space for hits in sector %d", sector,0,0,0,0 ) ;
00732 LOG(ERR, " maxHits %d nSectorHits %d nHits %d", maxHits,
00733 nSectorHits, nHits ,0,0) ;
00734 return 0 ;
00735 }
00736
00737 l3_cluster* cluster = (l3_cluster *)head->cluster ;
00738 l3_cluster* hitP ;
00739 gl3Hit* gHitP = 0 ;
00740
00741 for ( int i = 0 ; i < nSectorHits ; i++ ) {
00742 hitP = &(cluster[i]) ;
00743
00744
00745
00746 if ( hitProcessing > 1 ) {
00747 gHitP = &(hit[nHits+i]);
00748 gHitP->set (coordinateTransformer, sector, hitP);
00749 }
00750
00751
00752
00753
00754 int trkId = hitP->trackId ;
00755 if ( trkId < 0 || trkId > nSectorTracks ) {
00756 LOG(ERR, "gl3Event:readSectorHits: %d wrong track id in hit of sector %d \n",
00757 trkId, sector ,0,0,0) ;
00758 continue ;
00759 }
00760 int indexStore = (sector-1)*maxTracksSector+trkId ;
00761 if ( indexStore < 0 || indexStore > nSectors*maxTracksSector ) {
00762 LOG(ERR, "gl3Event:readSectorHits: %d wrong indexStore\n",
00763 indexStore ,0,0,0,0) ;
00764 continue ;
00765 }
00766 int index = trackIndex[indexStore] - 1 ;
00767 if ( index < 0 || index > nTracks ) continue ;
00768
00769
00770
00771
00772 if ( hitProcessing > 1 ) {
00773 if ( track[index].firstHit == 0 )
00774 track[index].firstHit = (void *)gHitP ;
00775 else
00776 ((gl3Hit *)(track[index].lastHit))->nextHit = (void *)gHitP ;
00777 track[index].lastHit = (void *)gHitP ;
00778 gHitP->trackId = track[index].id ;
00779 }
00780
00781
00782
00783 hitP->trackId = track[index].id ;
00784
00785
00786 }
00787 nHits += nSectorHits ;
00788
00789 return nSectorHits ;
00790 }
00791
00792
00793
00794
00795
00796
00797 int gl3Event::readSectorTracks ( char* buffer ){
00798
00799 struct L3_SECTP *head = (struct L3_SECTP *)buffer ;
00800
00801 if ( strncmp(head->bh.bank_type,CHAR_L3_SECTP,8) ) {
00802 LOG(ERR, "gl3Event::readSectorTracks, wrong bank type %s\n",
00803 head->bh.bank_type,0,0,0,0 ) ;
00804 return -1 ;
00805 }
00806
00807 int sector = head->bh.bank_id ;
00808 if ( sector < 0 || sector > nSectors ) {
00809 LOG(ERR," gl3Event::readSector: %d wrong sector \n", sector ,0,0,0,0) ;
00810 return 1 ;
00811 }
00812
00813 gl3Sector* sectorP = &(sectorInfo[sector-1]) ;
00814 sectorP->filled = 1 ;
00815 sectorP->nHits = head->nHits ;
00816 sectorP->nTracks = head->nTracks ;
00817 sectorP->cpuTime = head->cpuTime ;
00818 sectorP->realTime = head->realTime ;
00819 sectorP->xVert = float(head->xVert)/1000000 ;
00820 sectorP->yVert = float(head->yVert)/1000000 ;
00821 sectorP->zVert = float(head->zVert)/1000000 ;
00822 sectorP->rVert = sqrt((double)( sectorP->xVert*sectorP->xVert +
00823 sectorP->yVert*sectorP->yVert)) ;
00824 sectorP->phiVert = atan2((double)sectorP->yVert,(double)sectorP->xVert) ;
00825 if ( sectorP->phiVert < 0 ) sectorP->phiVert += 2. * M_PI ;
00826
00827
00828
00829
00830
00831 para.xVertex = sectorP->xVert ;
00832 para.yVertex = sectorP->yVert ;
00833 para.zVertex = sectorP->zVert ;
00834 para.rVertex = sectorP->rVert ;
00835 para.phiVertex = sectorP->phiVert ;
00836
00837 char* pointer = head->banks[0].off * 4 + buffer ;
00838 int nSectorTracks ;
00839
00840 if ( (head->banks[0].len > 0) && (head->bh.format_number > 0) ) {
00841
00842 nSectorTracks = (4 * head->banks[0].len - sizeof(struct bankHeader))
00843 /sizeof(struct local_track);
00844 }
00845 else nSectorTracks = 0 ;
00846
00847
00848
00849 if ( nSectorTracks > 0 ) {
00850 struct L3_LTD* headerLocal = (struct L3_LTD*)pointer ;
00851 local_track* localTrack = headerLocal->track ;
00852 addTracks ( sector, nSectorTracks, localTrack ) ;
00853 }
00854
00855
00856 return sectorP->nTracks ;
00857 }
00858
00859
00860
00861
00862
00863 int gl3Event::makeVertex (){
00864
00865
00866
00867
00868
00869 gl3Track* gTrack ;
00870 Ftf3DHit closestHit ;
00871
00872 hVz->Reset();
00873 hVx->Reset();
00874 hVy->Reset();
00875
00876
00877 vertex.Setxyz(0.0,0.0,0.0);
00878
00879
00880 for(int iter = 0 ; iter<2; iter++ ) {
00881
00882 for(int trkcnt = 0 ; trkcnt<getNTracks(); trkcnt++ ) {
00883 gTrack = getTrack(trkcnt);
00884
00885
00886
00887
00888 if ( gTrack->nHits > minNoOfHitsOnTrackUsedForVertexCalc &&
00889 gTrack->pt > minMomUsedForVertexCalc) {
00890
00891 closestHit = gTrack->closestApproach(getVertex().Getx(),
00892 getVertex().Gety());
00893
00894
00895
00896
00897 hVz->Fill(closestHit.z,1.0);
00898 hVx->Fill(closestHit.x,1.0);
00899 hVy->Fill(closestHit.y,1.0);
00900 }
00901 }
00902
00903
00904 vertex.Setxyz(hVx->getWeightedMean(6.0),
00905 hVy->getWeightedMean(6.0),
00906 hVz->getWeightedMean(4.0));
00907
00908 }
00909
00910
00911 return 0;
00912 }
00913
00914
00915
00916
00917 int gl3Event::resetEvent ( ){
00918 nHits = 0 ;
00919 nTracks = 0 ;
00920 nMergedTracks = 0 ;
00921 nMergableTracks = 0 ;
00922 nBadTracks = 0 ;
00923 busy = 0 ;
00924
00925
00926 memset(trackContainer, 0,
00927 para.nPhiTrackPlusOne*para.nEtaTrackPlusOne*sizeof(FtfContainer));
00928
00929
00930 if ( hitProcessing ) {
00931 memset ( trackIndex, 0, maxTracksSector*nSectors*sizeof(int) ) ;
00932 delete[] hit;
00933 hit = new gl3Hit[maxHits];
00934 }
00935
00936
00937 for (int i=0; i<16; i++)
00938 trgData.ZDC[i] = 0;
00939
00940 for (int i=0; i<240; i++)
00941 trgData.CTB[i] = 0;
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952 vertex.Setxyz(0.0, 0.0, 0.0);
00953
00954 emc.reset();
00955
00956 return 0 ;
00957 }
00958
00959
00960
00961
00962 int gl3Event::setup ( int mxHits, int mxTracks )
00963 {
00964
00965 if ( mxHits < 0 || mxHits > 1000000 ) {
00966 LOG(ERR, " gl3Event::setup: maxHits %d out of range \n", maxHits,0,0,0,0 ) ;
00967 mxHits = 500000 ;
00968 }
00969
00970 if ( mxTracks < 0 || mxTracks > 1000000 ) {
00971 LOG(ERR, " gl3Event::setup: maxTracks %d out of range \n", maxTracks,0,0,0,0 );
00972 mxTracks = 50000 ;
00973 }
00974
00975
00976 maxHits = mxHits ;
00977 maxTracks = mxTracks ;
00978 maxTracksSector = maxTracks*2/ nSectors ;
00979 hit = new gl3Hit[maxHits] ;
00980 track = new gl3Track[maxTracks] ;
00981 trackIndex = new int[maxTracksSector*nSectors];
00982
00983
00984
00985 nMergedTracks = 0 ;
00986
00987 para.nPhiTrackPlusOne = para.nPhiTrack + 1 ;
00988 para.nEtaTrackPlusOne = para.nEtaTrack + 1 ;
00989
00990
00991
00992 para.phiSliceTrack = (para.phiMaxTrack - para.phiMinTrack)/para.nPhiTrack;
00993 para.etaSliceTrack = (para.etaMaxTrack - para.etaMinTrack)/para.nEtaTrack;
00994
00995 int nTrackVolumes = para.nPhiTrackPlusOne* para.nEtaTrackPlusOne ;
00996 trackContainer = new FtfContainer[nTrackVolumes];
00997 if(trackContainer == NULL) {
00998 LOG(ERR, "Problem with memory allocation... exiting\n",0,0,0,0,0) ;
00999 return 1 ;
01000 }
01001 para.primaries = 1 ;
01002 para.ptMinHelixFit = 1.e60 ;
01003
01004 nTracks = 0 ;
01005
01006
01007
01008
01009 minNoOfHitsOnTrackUsedForVertexCalc=14;
01010 minMomUsedForVertexCalc=0.25;
01011
01012 char hid[50] ;
01013 char title[100] ;
01014
01015 strcpy ( hid, "Vertex_Vz" ) ;
01016 strcpy ( title, "Vertex_Vz" ) ;
01017 hVz = new gl3Histo ( hid, title, 400, -200., 200. ) ;
01018
01019 strcpy ( hid, "Vertex_Vx" ) ;
01020 strcpy ( title, "Vertex_Vx" ) ;
01021 hVx = new gl3Histo ( hid, title, 100,-10,10);
01022
01023 strcpy ( hid, "Vertex_Vy" ) ;
01024 strcpy ( title, "Vertex_Vy" ) ;
01025 hVy = new gl3Histo ( hid, title, 100,-10,10);
01026
01027
01028
01029 return 0 ;
01030 }
Generated on Sun Mar 15 04:50:50 2009 for StRoot by
1.3.7