2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project *
4 // ALICE Experiment at CERN, All rights reserved. *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 // Ivan Kisel <kisel@kip.uni-heidelberg.de> *
8 // for The ALICE HLT Project. *
10 // Permission to use, copy, modify and distribute this software and its *
11 // documentation strictly for non-commercial purposes is hereby granted *
12 // without fee, provided that the above copyright notice appears in all *
13 // copies and that both the copyright notice and this permission notice *
14 // appear in the supporting documentation. The authors make no claims *
15 // about the suitability of this software for any purpose. It is *
16 // provided "as is" without express or implied warranty. *
18 //***************************************************************************
21 ///////////////////////////////////////////////////////////////////////////////
23 // a TPC tracker processing component for the HLT based on CA by Ivan Kisel //
25 ///////////////////////////////////////////////////////////////////////////////
31 #include "AliHLTTPCCATrackerComponent.h"
32 #include "AliHLTTPCTransform.h"
33 #include "AliHLTTPCCATracker.h"
34 #include "AliHLTTPCCAOutTrack.h"
35 #include "AliHLTTPCCAParam.h"
36 #include "AliHLTTPCCATrackConvertor.h"
38 #include "AliHLTTPCSpacePointData.h"
39 #include "AliHLTTPCClusterDataFormat.h"
40 #include "AliHLTTPCTransform.h"
41 #include "AliHLTTPCTrackSegmentData.h"
42 #include "AliHLTTPCTrackArray.h"
43 #include "AliHLTTPCTrackletDataFormat.h"
44 #include "AliHLTTPCDefinitions.h"
45 #include "AliExternalTrackParam.h"
46 #include "TStopwatch.h"
48 #include "AliCDBEntry.h"
49 #include "AliCDBManager.h"
50 #include "TObjString.h"
51 #include "TObjArray.h"
52 #include "AliHLTTPCCASliceOutput.h"
54 const AliHLTComponentDataType AliHLTTPCCADefinitions::fgkTrackletsDataType = AliHLTComponentDataTypeInitializer( "CATRACKL", kAliHLTDataOriginTPC );
56 /** ROOT macro for the implementation of ROOT specific class methods */
57 ClassImp(AliHLTTPCCATrackerComponent)
59 /** global object for registration
60 * Matthias 2009-01-13 temporarily using the global object approach again.
61 * CA cade had to be disabled because of various compilation problems, so
62 * the global object approach fits better for the moment.
65 AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
67 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
71 fMinNTrackClusters(0),
78 // see header file for class documentation
80 // refer to README to build package
82 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
85 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent(const AliHLTTPCCATrackerComponent&)
90 fMinNTrackClusters(30),
97 // see header file for class documentation
98 HLTFatal("copy constructor untested");
101 AliHLTTPCCATrackerComponent& AliHLTTPCCATrackerComponent::operator=(const AliHLTTPCCATrackerComponent&)
103 // see header file for class documentation
104 HLTFatal("assignment operator untested");
108 AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
110 // see header file for class documentation
115 // Public functions to implement AliHLTComponent's interface.
116 // These functions are required for the registration process
119 const char* AliHLTTPCCATrackerComponent::GetComponentID()
121 // see header file for class documentation
122 return "TPCCATracker";
125 void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
127 // see header file for class documentation
129 list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
132 AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
134 // see header file for class documentation
135 if( fNewOutputType ) return AliHLTTPCCADefinitions::fgkTrackletsDataType;
136 else return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
139 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
141 // define guess for the output data size
142 constBase = 200; // minimum size
143 inputMultiplier = 0.5; // size relative to input
146 AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
148 // see header file for class documentation
149 return new AliHLTTPCCATrackerComponent;
152 Int_t AliHLTTPCCATrackerComponent::DoInit( Int_t argc, const char** argv )
154 // Configure the CA tracker component
157 fMinNTrackClusters = 0;
164 if ( fTracker ) return EINPROGRESS;
165 fTracker = new AliHLTTPCCATracker();
169 TString arguments="";
170 for (int i=0; i<argc; i++) {
171 TString argument=argv[i];
172 if (!arguments.IsNull()) arguments+=" ";
175 if (!arguments.IsNull()) {
176 iResult=Configure(arguments.Data());
178 iResult=Reconfigure(NULL, NULL);
184 Int_t AliHLTTPCCATrackerComponent::DoDeinit()
186 // see header file for class documentation
187 if ( fTracker ) delete fTracker;
192 Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
194 // see header file for class documentation
196 HLTWarning("TODO: dummy Reconfigure() method" );
203 const char* path="HLT/ConfigTPC/CATrackerComponent";
204 const char* defaultNotify="";
207 defaultNotify=" (default)";
210 HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
211 AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo());
213 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
215 HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
216 iResult=Configure(pString->GetString().Data());
218 HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
221 HLTError("cannot fetch object \"%s\" from CDB", path);
225 const char* pathBField=kAliHLTCDBSolenoidBz;
228 HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
229 AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
231 TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
233 HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
234 iResult=Configure(pString->GetString().Data());
236 HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
239 HLTError("cannot fetch object \"%s\" from CDB", path);
247 Bool_t AliHLTTPCCATrackerComponent::CompareClusters(AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b)
249 //* Comparison function for sorting clusters
250 if( a->fPadRow<b->fPadRow ) return 1;
251 if( a->fPadRow>b->fPadRow ) return 0;
252 return (a->fZ < b->fZ);
256 Int_t AliHLTTPCCATrackerComponent::Configure( const char* arguments )
261 if (!arguments) return iResult;
263 TString allArgs=arguments;
265 Int_t bMissingParam=0;
267 TObjArray* pTokens=allArgs.Tokenize(" ");
269 Int_t nArgs = pTokens ?pTokens->GetEntries() :0;
271 for (int i=0; i<nArgs; i++ ){
272 argument=((TObjString*)pTokens->At(i))->GetString();
273 if (argument.IsNull()){
275 else if (argument.CompareTo("-solenoidBz")==0 ){
276 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
277 fSolenoidBz = ((TObjString*)pTokens->At(i))->GetString().Atof();
278 HLTInfo("Magnetic Field set to: %f", fSolenoidBz );
280 else if ( argument.CompareTo("-minNClustersOnTrack")==0 ||
281 argument.CompareTo("-minNTrackClusters")==0 ){
282 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
283 fMinNTrackClusters = ((TObjString*)pTokens->At(i))->GetString().Atoi();
284 HLTInfo("minNClustersOnTrack set to: %d", fMinNTrackClusters );
286 else if ( argument.CompareTo("-clusterZCut")==0 ){
287 if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
288 fClusterZCut = TMath::Abs( ((TObjString*)pTokens->At(i))->GetString().Atof());
289 HLTInfo("ClusterZCut set to: %f", fClusterZCut );
291 else if ( argument.CompareTo("-newOutputType")==0 ){
293 HLTInfo("NewOutputType is set");
296 HLTError("Unknown option %s ", argument.Data());
303 HLTError("Specifier missed for %s", argument.Data());
313 Int_t AliHLTTPCCATrackerComponent::DoEvent
315 const AliHLTComponentEventData& evtData,
316 const AliHLTComponentBlockData* blocks,
317 AliHLTComponentTriggerData& /*trigData*/,
318 AliHLTUInt8_t* outputPtr,
319 AliHLTUInt32_t& size,
320 vector<AliHLTComponentBlockData>& outputBlocks )
323 AliHLTUInt32_t maxBufferSize = size;
324 size = 0; // output size
326 if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
332 // Event reconstruction in one TPC slice with CA Tracker
334 //Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA::DoEvent()" );
335 if ( evtData.fBlockCnt<=0 )
337 HLTWarning("no blocks in event" );
341 const AliHLTComponentBlockData* iter = NULL;
343 AliHLTTPCClusterData* inPtrSP;
345 // Determine the slice number
349 std::vector<Int_t> slices;
350 std::vector<Int_t>::iterator slIter;
351 std::vector<unsigned> sliceCnts;
352 std::vector<unsigned>::iterator slCntIter;
354 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ){
356 if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType ) continue;
358 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
361 slCntIter = sliceCnts.begin();
362 for( slIter = slices.begin(); slIter!=slices.end(); slIter++, slCntIter++ ){
363 if ( *slIter == slice ){
369 slices.push_back( slice );
370 sliceCnts.push_back( 1 );
375 // Determine slice number to really use.
376 if ( slices.size()>1 )
378 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
379 "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
380 evtData.fEventID, evtData.fEventID );
381 unsigned maxCntSlice=0;
382 slCntIter = sliceCnts.begin();
383 for( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ )
385 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
386 "Slice %lu found %lu times.", *slIter, *slCntIter );
387 if ( maxCntSlice<*slCntIter )
389 maxCntSlice = *slCntIter;
393 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
394 "Using slice %lu.", slice );
396 else if ( slices.size()>0 )
398 slice = *(slices.begin());
403 HLTWarning("no slices found in event" );
408 // Initialize the tracker
412 if( !fTracker ) fTracker = new AliHLTTPCCATracker;
414 Float_t inRmin = 83.65;
415 // Float_t inRmax = 133.3;
416 // Float_t outRmin = 133.5;
417 Float_t outRmax = 247.7;
418 Float_t plusZmin = 0.0529937;
419 Float_t plusZmax = 249.778;
420 Float_t minusZmin = -249.645;
421 Float_t minusZmax = -0.0799937;
422 Float_t dalpha = 0.349066;
423 Float_t alpha = 0.174533 + dalpha*iSec;
425 Bool_t zPlus = (iSec<18 );
426 Float_t zMin = zPlus ?plusZmin :minusZmin;
427 Float_t zMax = zPlus ?plusZmax :minusZmax;
428 //TPCZmin = -249.645, ZMax = 249.778
429 // Float_t rMin = inRmin;
430 // Float_t rMax = outRmax;
431 Int_t nRows = AliHLTTPCTransform::GetNRows();
433 Float_t padPitch = 0.4;
434 Float_t sigmaZ = 0.228808;
436 Float_t *rowX = new Float_t [nRows];
437 for( Int_t irow=0; irow<nRows; irow++){
438 rowX[irow] = AliHLTTPCTransform::Row2X( irow );
441 AliHLTTPCCAParam param;
442 param.Initialize( iSec, nRows, rowX, alpha, dalpha,
443 inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
444 param.SetHitPickUpFactor( 2 );
446 fTracker->Initialize( param );
451 // min and max patch numbers and row numbers
453 Int_t row[2] = {0,0};
454 Int_t minPatch=100, maxPatch = -1;
458 Int_t nHitsTotal = 0;
462 std::vector<unsigned long> patchIndices;
464 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ){
466 if( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType ) continue;
467 if( slice!=AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) continue;
468 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
469 nHitsTotal+=inPtrSP->fSpacePointCnt;
470 Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
471 if ( minPatch>patch ){
473 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
475 if ( maxPatch<patch ){
477 row[1] = AliHLTTPCTransform::GetLastRow( patch );
479 std::vector<unsigned long>::iterator pIter = patchIndices.begin();
480 while( pIter!=patchIndices.end() && AliHLTTPCDefinitions::GetMinPatchNr( blocks[*pIter] ) < patch ){
483 patchIndices.insert( pIter, ndx );
487 // pass event to CA Tracker
489 fTracker->StartEvent();
491 Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
492 "Total %d hits to read for slice %d", nHitsTotal, slice );
495 AliHLTTPCSpacePointData** vOrigClusters = new AliHLTTPCSpacePointData* [ nHitsTotal];
499 for( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter!=patchIndices.end(); pIter++ ){
503 Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
504 inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
506 Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
507 "Reading %d hits for slice %d - patch %d", inPtrSP->fSpacePointCnt, slice, patch );
509 for (UInt_t i=0; i<inPtrSP->fSpacePointCnt; i++ ){
510 vOrigClusters[nClusters++] = &(inPtrSP->fSpacePoints[i]);
514 // sort clusters since they are not sorted fore some reason
516 sort( vOrigClusters, vOrigClusters+nClusters, CompareClusters );
518 Float_t *vHitStoreX = new Float_t [nHitsTotal]; // hit X coordinates
519 Float_t *vHitStoreY = new Float_t [nHitsTotal]; // hit Y coordinates
520 Float_t *vHitStoreZ = new Float_t [nHitsTotal]; // hit Z coordinates
521 Int_t *vHitStoreIntID = new Int_t [nHitsTotal]; // hit ID's
522 Int_t *vHitStoreID = new Int_t [nHitsTotal]; // hit ID's
523 Int_t *vHitRowID = new Int_t [nHitsTotal]; // hit ID's
529 Int_t rowFirstHits[200];
530 for( Int_t ir=0; ir<200; ir++ ) rowNHits[ir] = 0;
532 for (Int_t i=0; i<nClusters; i++ ){
533 AliHLTTPCSpacePointData* pSP = vOrigClusters[i];
534 if( oldRow>=0 && pSP->fPadRow < oldRow )
535 HLTError("CA: clusters from row %d are readed twice",oldRow);
537 if( TMath::Abs(pSP->fZ)>fClusterZCut) continue;
539 vHitStoreX[nHits] = pSP->fX;
540 vHitStoreY[nHits] = pSP->fY;
541 vHitStoreZ[nHits] = pSP->fZ;
542 vHitStoreIntID[nHits] = nHits;
543 vHitStoreID[nHits] = pSP->fID;
544 vHitRowID[nHits] = pSP->fPadRow;
546 rowNHits[pSP->fPadRow]++;
549 Int_t firstRowHit = 0;
550 for( Int_t ir=0; ir<200; ir++ ){
551 rowFirstHits[ir] = firstRowHit;
552 firstRowHit+=rowNHits[ir];
555 fTracker->ReadEvent( rowFirstHits, rowNHits, vHitStoreY, vHitStoreZ, nHits );
558 if( vOrigClusters ) delete[] vOrigClusters;
560 // reconstruct the event
562 TStopwatch timerReco;
564 fTracker->Reconstruct();
570 Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
571 "%d tracks found for slice %d",fTracker->NOutTracks(), slice);
574 // write reconstructed tracks
577 Int_t ntracks = *fTracker->NOutTracks();
580 if( !fNewOutputType ){
582 AliHLTTPCTrackletData* outPtr = (AliHLTTPCTrackletData*)(outputPtr);
584 AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
586 mySize = ((AliHLTUInt8_t *)currOutTracklet) - ((AliHLTUInt8_t *)outputPtr);
588 outPtr->fTrackletCnt = 0;
590 for( Int_t itr=0; itr<ntracks; itr++ ){
592 AliHLTTPCCAOutTrack &t = fTracker->OutTracks()[itr];
594 //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Wrtite output","track %d with %d hits", itr, t.NHits());
596 if( t.NHits()<fMinNTrackClusters ) continue;
598 // calculate output track size
600 UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
602 if( mySize + dSize > maxBufferSize ){
603 HLTWarning("Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, ntracks-itr+1);
608 // convert CA track parameters to HLT Track Segment
610 Int_t iFirstRow = 1000;
612 Int_t iFirstHit = fTracker->OutTrackHits()[t.FirstHitRef()];
613 Int_t iLastHit = iFirstHit;
614 for( Int_t ih=0; ih<t.NHits(); ih++ ){
615 Int_t hitID = fTracker->OutTrackHits()[t.FirstHitRef() + ih ];
616 Int_t iRow = vHitRowID[hitID];
617 if( iRow<iFirstRow ){ iFirstRow = iRow; iFirstHit = hitID; }
618 if( iRow>iLastRow ){ iLastRow = iRow; iLastHit = hitID; }
621 AliHLTTPCCATrackParam par = t.StartPoint();
623 par.TransportToX( vHitStoreX[iFirstHit], .99 );
625 AliExternalTrackParam tp;
626 AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0, fSolenoidBz );
628 currOutTracklet->fX = tp.GetX();
629 currOutTracklet->fY = tp.GetY();
630 currOutTracklet->fZ = tp.GetZ();
631 currOutTracklet->fCharge = (Int_t ) tp.GetSign();
632 currOutTracklet->fPt = TMath::Abs(tp.GetSignedPt());
633 Float_t snp = tp.GetSnp() ;
634 if( snp>.999 ) snp=.999;
635 if( snp<-.999 ) snp=-.999;
636 currOutTracklet->fPsi = TMath::ASin( snp );
637 currOutTracklet->fTgl = tp.GetTgl();
639 currOutTracklet->fY0err = tp.GetSigmaY2();
640 currOutTracklet->fZ0err = tp.GetSigmaZ2();
641 Float_t h = -currOutTracklet->fPt*currOutTracklet->fPt;
642 currOutTracklet->fPterr = h*h*tp.GetSigma1Pt2();
643 h = 1./TMath::Sqrt(1-snp*snp);
644 currOutTracklet->fPsierr = h*h*tp.GetSigmaSnp2();
645 currOutTracklet->fTglerr = tp.GetSigmaTgl2();
647 if( par.TransportToX( vHitStoreX[iLastHit],.99 ) ){
648 currOutTracklet->fLastX = par.GetX();
649 currOutTracklet->fLastY = par.GetY();
650 currOutTracklet->fLastZ = par.GetZ();
652 currOutTracklet->fLastX = vHitStoreX[iLastHit];
653 currOutTracklet->fLastY = vHitStoreY[iLastHit];
654 currOutTracklet->fLastZ = vHitStoreZ[iLastHit];
656 //if( currOutTracklet->fLastX<10. ) {
657 //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",vHitStoreX[iLastHit],vHitStoreY[iLastHit],vHitStoreZ[iLastHit],
658 //par.GetX(), par.GetY(),par.GetZ(),currOutTracklet->fLastX,currOutTracklet->fLastY ,currOutTracklet->fLastZ, t.NHits());
660 #ifdef INCLUDE_TPC_HOUGH
661 #ifdef ROWHOUGHPARAMS
662 currOutTracklet->fTrackID = 0;
663 currOutTracklet->fRowRange1 = vHitRowID[iFirstHit];
664 currOutTracklet->fRowRange2 = vHitRowID[iLastHit];
665 currOutTracklet->fSector = slice;
666 currOutTracklet->fPID = 211;
668 #endif // INCLUDE_TPC_HOUGH
671 currOutTracklet->fNPoints = t.NHits();
673 for( Int_t i=0; i<t.NHits(); i++ ){
674 currOutTracklet->fPointIDs[i] = vHitStoreID[fTracker->OutTrackHits()[t.FirstHitRef()+i]];
677 currOutTracklet = (AliHLTTPCTrackSegmentData*)( (Byte_t *)currOutTracklet + dSize );
679 outPtr->fTrackletCnt++;
681 } else { // new output type
683 mySize = fTracker->Output()->EstimateSize( fTracker->Output()->NTracks(),
684 fTracker->Output()->NTrackClusters() );
685 if( mySize <= maxBufferSize ){
686 const AliHLTUInt8_t* outputevent = reinterpret_cast<const AliHLTUInt8_t*>(fTracker->Output());
687 for( UInt_t i=0; i<mySize; i++ ) outputPtr[i] = outputevent[i];
689 HLTWarning("Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
695 if( vHitStoreX ) delete[] vHitStoreX;
696 if( vHitStoreY ) delete[] vHitStoreY;
697 if( vHitStoreZ ) delete[] vHitStoreZ;
698 if( vHitStoreIntID ) delete[] vHitStoreIntID;
699 if( vHitStoreID ) delete[] vHitStoreID;
700 if( vHitRowID ) delete[] vHitRowID;
703 AliHLTComponentBlockData bd;
707 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
708 outputBlocks.push_back( bd );
714 fFullTime+= timer.RealTime();
715 fRecoTime+= timerReco.RealTime();
718 // Set log level to "Warning" for on-line system monitoring
719 Int_t hz = (Int_t) (fFullTime>1.e-10 ?fNEvents/fFullTime :100000);
720 Int_t hz1 = (Int_t) (fRecoTime>1.e-10 ?fNEvents/fRecoTime :100000);
721 HLTInfo( "CATracker slice %d: output %d tracks; input %d clusters, patches %d..%d, rows %d..%d; reco time %d/%d Hz",
722 slice, ntracks, nClusters, minPatch, maxPatch, row[0], row[1], hz, hz1 );