From 055fed306b6b7d4d221df124f8cd04716267e031 Mon Sep 17 00:00:00 2001 From: richterm Date: Tue, 6 Nov 2007 15:35:42 +0000 Subject: [PATCH] HLT TPC Conformal mapping tracker running in AliRoot - changes in conformal mapping tracker to postpone large memory allocation to the place where it's needed - bugfix in FileHandler to deliver correct HLT raw TPC format - bugfix in DigitReaderUnpacked to treat rows similar to other digut readers - benchmark logging level introduced --- HLT/TPCLib/AliHLTTPCConfMapPoint.cxx | 141 +++++++++++++++--- HLT/TPCLib/AliHLTTPCConfMapPoint.h | 22 ++- HLT/TPCLib/AliHLTTPCConfMapper.cxx | 80 +++++----- HLT/TPCLib/AliHLTTPCConfMapper.h | 20 ++- HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx | 5 +- HLT/TPCLib/AliHLTTPCFileHandler.cxx | 58 ++++--- HLT/TPCLib/AliHLTTPCLog.h | 2 +- HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx | 2 + HLT/TPCLib/AliHLTTPCTrackArray.cxx | 1 + HLT/TPCLib/AliHLTTPCTrackArray.h | 7 +- HLT/TPCLib/AliHLTTPCTransform.cxx | 3 +- .../AliHLTTPCDigitPublisherComponent.cxx | 12 +- 12 files changed, 254 insertions(+), 99 deletions(-) diff --git a/HLT/TPCLib/AliHLTTPCConfMapPoint.cxx b/HLT/TPCLib/AliHLTTPCConfMapPoint.cxx index 421200df374..a0bdbb0fd69 100644 --- a/HLT/TPCLib/AliHLTTPCConfMapPoint.cxx +++ b/HLT/TPCLib/AliHLTTPCConfMapPoint.cxx @@ -24,6 +24,7 @@ @brief Hit class for conformal mapper */ +#include #include "AliHLTTPCLogging.h" #include "AliHLTTPCConfMapPoint.h" #include "AliHLTTPCSpacePointData.h" @@ -49,7 +50,7 @@ AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint() fHitNumber(-1), fTrackNumber(0), fNextHitNumber(0), - fUsed(0), + fUsed(kFALSE), fPadrow(0), fSector(0), fx(0), @@ -79,20 +80,116 @@ AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint() fZverr(0), fPhi(0), fEta(0), - fNextVolumeHit(0), - fNextRowHit(0), - fNextTrackHit(0), + fNextVolumeHit(NULL), + fNextRowHit(NULL), + fNextTrackHit(NULL), fPhiIndex(0), fEtaIndex(0), fXYChi2(0), fSZChi2(0) { //Constructor - - SetUsage(false); - SetIntPoint(0., 0., 0., 0., 0., 0.); - SetShiftedCoord(); - SetMCTrackID(0,0,0); + fMCTrackID[0]=-1; + fMCTrackID[1]=-1; + fMCTrackID[2]=-1; +} + +AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint& src) + : + fHitNumber(src.fHitNumber), + fTrackNumber(src.fTrackNumber), + fNextHitNumber(src.fNextHitNumber), + fUsed(src.fUsed), + fPadrow(src.fPadrow), + fSector(src.fSector), + fx(src.fx), + fy(src.fy), + fz(src.fz), + fxerr(src.fxerr), + fyerr(src.fyerr), + fzerr(src.fzerr), + fWxy(src.fWxy), + fWz(src.fWz), + fs(src.fs), + fXt(src.fXt), + fYt(src.fYt), + fZt(src.fZt), + fXterr(src.fXterr), + fYterr(src.fYterr), + fZterr(src.fZterr), + fXprime(src.fXprime), + fYprime(src.fYprime), + fXprimeerr(src.fXprimeerr), + fYprimeerr(src.fYprimeerr), + fXv(src.fXv), + fYv(src.fYv), + fZv(src.fZv), + fXverr(src.fXverr), + fYverr(src.fYverr), + fZverr(src.fZverr), + fPhi(src.fPhi), + fEta(src.fEta), + fNextVolumeHit(src.fNextVolumeHit), + fNextRowHit(src.fNextRowHit), + fNextTrackHit(src.fNextTrackHit), + fPhiIndex(src.fPhiIndex), + fEtaIndex(src.fEtaIndex), + fXYChi2(src.fXYChi2), + fSZChi2(src.fSZChi2) +{ + //Copy Constructor + fMCTrackID[0]=src.fMCTrackID[0]; + fMCTrackID[1]=src.fMCTrackID[1]; + fMCTrackID[2]=src.fMCTrackID[2]; +} + +AliHLTTPCConfMapPoint& AliHLTTPCConfMapPoint::operator=(const AliHLTTPCConfMapPoint& src) +{ + fHitNumber=src.fHitNumber; + fTrackNumber=src.fTrackNumber; + fNextHitNumber=src.fNextHitNumber; + fUsed=src.fUsed; + fPadrow=src.fPadrow; + fSector=src.fSector; + fx=src.fx; + fy=src.fy; + fz=src.fz; + fxerr=src.fxerr; + fyerr=src.fyerr; + fzerr=src.fzerr; + fWxy=src.fWxy; + fWz=src.fWz; + fs=src.fs; + fXt=src.fXt; + fYt=src.fYt; + fZt=src.fZt; + fXterr=src.fXterr; + fYterr=src.fYterr; + fZterr=src.fZterr; + fXprime=src.fXprime; + fYprime=src.fYprime; + fXprimeerr=src.fXprimeerr; + fYprimeerr=src.fYprimeerr; + fXv=src.fXv; + fYv=src.fYv; + fZv=src.fZv; + fXverr=src.fXverr; + fYverr=src.fYverr; + fZverr=src.fZverr; + fPhi=src.fPhi; + fEta=src.fEta; + fNextVolumeHit=src.fNextVolumeHit; + fNextRowHit=src.fNextRowHit; + fNextTrackHit=src.fNextTrackHit; + fPhiIndex=src.fPhiIndex; + fEtaIndex=src.fEtaIndex; + fXYChi2=src.fXYChi2; + fSZChi2=src.fSZChi2; + fMCTrackID[0]=src.fMCTrackID[0]; + fMCTrackID[1]=src.fMCTrackID[1]; + fMCTrackID[2]=src.fMCTrackID[2]; + + return *this; } AliHLTTPCConfMapPoint::~AliHLTTPCConfMapPoint() @@ -100,19 +197,19 @@ AliHLTTPCConfMapPoint::~AliHLTTPCConfMapPoint() // Destructor. } -Bool_t AliHLTTPCConfMapPoint::ReadHits(AliHLTTPCSpacePointData* hits ) +Bool_t AliHLTTPCConfMapPoint::Read(const AliHLTTPCSpacePointData& hit) { //read the hits - SetHitNumber(hits->fID); - SetPadRow(hits->fPadRow); - Int_t slice = (hits->fID>>25) & 0x7f; + SetHitNumber(hit.fID); + SetPadRow(hit.fPadRow); + Int_t slice = (hit.fID>>25) & 0x7f; SetSector(slice); - SetX(hits->fX); - SetY(hits->fY); - SetZ(hits->fZ); - SetXerr(sqrt(hits->fSigmaY2)); - SetYerr(sqrt(hits->fSigmaY2)); - SetZerr(sqrt(hits->fSigmaZ2)); + SetX(hit.fX); + SetY(hit.fY); + SetZ(hit.fZ); + SetXerr(sqrt(hit.fSigmaY2)); + SetYerr(sqrt(hit.fSigmaY2)); + SetZerr(sqrt(hit.fSigmaZ2)); return kTRUE; } @@ -121,9 +218,9 @@ void AliHLTTPCConfMapPoint::Reset() //Reset this point. SetUsage(kFALSE); SetS(0); - fNextRowHit = 0; - fNextVolumeHit=0; - fNextTrackHit=0; + fNextRowHit = NULL; + fNextVolumeHit=NULL; + fNextTrackHit=NULL; } void AliHLTTPCConfMapPoint::Setup(AliHLTTPCVertex *vertex) diff --git a/HLT/TPCLib/AliHLTTPCConfMapPoint.h b/HLT/TPCLib/AliHLTTPCConfMapPoint.h index 082643e1430..d030576a639 100644 --- a/HLT/TPCLib/AliHLTTPCConfMapPoint.h +++ b/HLT/TPCLib/AliHLTTPCConfMapPoint.h @@ -27,13 +27,26 @@ class AliHLTTPCVertex; class AliHLTTPCConfMapPoint { public: - + /** constructor */ AliHLTTPCConfMapPoint(); + /** copy constructor */ + AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint&); + /** assignment operator */ + AliHLTTPCConfMapPoint& operator=(const AliHLTTPCConfMapPoint&); /** destructor */ virtual ~AliHLTTPCConfMapPoint(); + /** + * Reset this point. + * The usage flag will be cleared as well as variables are reset. + */ void Reset(); - Bool_t ReadHits(AliHLTTPCSpacePointData* hits ); + + /** + * Read one hit. + * Set members from AliHLTTPCSpacePointData. + */ + Bool_t Read(const AliHLTTPCSpacePointData& hit); // getter Double_t GetX() const {return fx;} @@ -84,7 +97,6 @@ class AliHLTTPCConfMapPoint { Short_t GetEtaIndex() const {return fEtaIndex;} Double_t GetXYChi2() const {return fXYChi2;} Double_t GetSZChi2() const {return fSZChi2;} - //Int_t fMCTrackID[3]; //MClabel of tracks, may overlap // setter void SetNextVolumeHit(AliHLTTPCConfMapPoint* p){fNextVolumeHit=p;} @@ -145,10 +157,6 @@ class AliHLTTPCConfMapPoint { void SetConfCoord();// conformal mapping private: - /** copy constructor prohibited */ - AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint&); - /** assignment operator prohibited */ - AliHLTTPCConfMapPoint& operator=(const AliHLTTPCConfMapPoint&); Int_t fHitNumber; //hit number Int_t fTrackNumber; //track number diff --git a/HLT/TPCLib/AliHLTTPCConfMapper.cxx b/HLT/TPCLib/AliHLTTPCConfMapper.cxx index 27b72fc0ac1..289de257398 100644 --- a/HLT/TPCLib/AliHLTTPCConfMapper.cxx +++ b/HLT/TPCLib/AliHLTTPCConfMapper.cxx @@ -13,6 +13,7 @@ */ +#include #include #include "AliHLTTPCRootTypes.h" @@ -37,7 +38,7 @@ AliHLTTPCConfMapper::AliHLTTPCConfMapper() fNTracks(0), fVertex(NULL), fVertexFinder(kFALSE), - fHit(NULL), + fHit(), fTrack(NULL), fMaxDca(0.0), // no clue whether this is reasonable, but at least better than without initialization fVolume(NULL), @@ -68,15 +69,9 @@ AliHLTTPCConfMapper::AliHLTTPCConfMapper() AliHLTTPCConfMapper::~AliHLTTPCConfMapper() { // Destructor. - if(fVolume) { - delete [] fVolume; - } if(fRow) { delete [] fRow; } - if(fHit) { - delete [] fHit; - } if(fTrack) { delete fTrack; } @@ -94,32 +89,21 @@ void AliHLTTPCConfMapper::InitVolumes() fNumEtaSegmentPlusOne = fNumEtaSegment+1; fNumPhiEtaSegmentPlusOne = fNumPhiSegmentPlusOne*fNumEtaSegmentPlusOne; fBounds = fNumRowSegmentPlusOne * fNumPhiSegmentPlusOne * fNumEtaSegmentPlusOne; + + Reset(); - //Allocate volumes: + fTrack = new AliHLTTPCTrackArray("AliHLTTPCConfMapTrack",10); +} + +void AliHLTTPCConfMapper::Reset() +{ if(fVolume) delete [] fVolume; + fVolume=NULL; if(fRow) delete [] fRow; + fRow=NULL; - LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::InitVolumes","Memory")<=fClustersUnused+count); + for (Int_t i=0;(UInt_t)i=fClustersUnused); for(Int_t j=0; jAt(j); AliHLTTPCConfMapPoint *thisHit = &(fHit[j]); thisHit->Setup(fVertex); @@ -259,7 +256,7 @@ void AliHLTTPCConfMapper::SetPointers() <GetNextVolumeHit()) { @@ -895,7 +893,7 @@ Int_t AliHLTTPCConfMapper::FillTracks() return 0; } - LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::FillTracks","fNTracks")<Sort(); diff --git a/HLT/TPCLib/AliHLTTPCConfMapper.h b/HLT/TPCLib/AliHLTTPCConfMapper.h index d13a66fabe9..a4e7104d322 100644 --- a/HLT/TPCLib/AliHLTTPCConfMapper.h +++ b/HLT/TPCLib/AliHLTTPCConfMapper.h @@ -10,6 +10,7 @@ // Author: Anders Vestbo //*-- Copyright © ALICE HLT Group +#include class AliHLTTPCConfMapPoint; class AliHLTTPCConfMapTrack; @@ -27,7 +28,16 @@ class AliHLTTPCConfMapper { /** destructor */ virtual ~AliHLTTPCConfMapper(); + /** + * Init and calculate bounds for the internal arrays. + */ void InitVolumes(); + + /** + * Reset internal arrays and free memory. + */ + void Reset(); + void InitSector(Int_t sector,Int_t *rowrange=0,Float_t *etarange=0); void SetVertex(AliHLTTPCVertex *vertex){fVertex = vertex;} void MainVertexTrackingA(); @@ -38,6 +48,13 @@ class AliHLTTPCConfMapper { Int_t rowscopetracklet, Int_t rowscopetrack,Double_t maxphi=0.1,Double_t maxeta=0.1); void NonVertexSettings(Int_t trackletlength, Int_t tracklength, Int_t rowscopetracklet, Int_t rowscopetrack); + + /** + * Read an array of space point data. + * @param count array size + * @param hits array + * @return kTRUE if success. + */ Bool_t ReadHits(UInt_t count, AliHLTTPCSpacePointData* hits ); void ClusterLoop(); void CreateTrack(AliHLTTPCConfMapPoint *hit); @@ -98,7 +115,8 @@ class AliHLTTPCConfMapper { Bool_t fVertexFinder; //Include vertexfinding or not //(latter case vertex=(0,0,0)) - AliHLTTPCConfMapPoint *fHit; //! + /** the list of hits */ + vector fHit; //! AliHLTTPCTrackArray *fTrack; //! Double_t fMaxDca; //cut value for momentum fit diff --git a/HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx b/HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx index 146a12ff93e..9dfe2fda3a6 100644 --- a/HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx +++ b/HLT/TPCLib/AliHLTTPCDigitReaderUnpacked.cxx @@ -70,8 +70,9 @@ int AliHLTTPCDigitReaderUnpacked::InitBlock(void* ptr,unsigned long size, Int_t fBin = -1; - fFirstRow=AliHLTTPCTransform::GetFirstRow(patch); - fLastRow=AliHLTTPCTransform::GetLastRow(patch); + int dummy=0; + AliHLTTPCTransform::Slice2Sector(slice, AliHLTTPCTransform::GetFirstRow(patch), dummy, fFirstRow); + AliHLTTPCTransform::Slice2Sector(slice, AliHLTTPCTransform::GetLastRow(patch), dummy, fLastRow); fRow = fFirstRow; diff --git a/HLT/TPCLib/AliHLTTPCFileHandler.cxx b/HLT/TPCLib/AliHLTTPCFileHandler.cxx index 4a155895d1a..16c677b4b7c 100644 --- a/HLT/TPCLib/AliHLTTPCFileHandler.cxx +++ b/HLT/TPCLib/AliHLTTPCFileHandler.cxx @@ -31,7 +31,7 @@ // or // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt */ - +#include #include #include #include @@ -383,6 +383,7 @@ Bool_t AliHLTTPCFileHandler::CreateIndex() LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::CreateIndex","Index") <<"Starting to create index, this can take a while."<GetEntries(); n++) { Int_t sector, row; Int_t lslice,lrow; @@ -442,7 +443,6 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int UShort_t dig; Int_t time,pad,sector,row; - Int_t lslice,lrow; Int_t nrows=0; Int_t ndigitcount=0; Int_t entries = (Int_t)fDigitsTree->GetEntries(); @@ -483,9 +483,12 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int for(Int_t r=fRowMin;r<=fRowMax;r++){ Int_t n=fIndex[fSlice][r]; if(n!=-1){ // there is data on that row available + Int_t lslice,lrow; fDigitsTree->GetEvent(n); fParam->AdjustSectorRow(fDigits->GetID(),sector,row); AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row); +// LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::AliDigits2Memory","Digits") +// << "Sector "<Next()); //cout << lrow << " " << ndigits[lrow] << " - " << ndigitcount << endl; } - nrows++; + //see comment below//nrows++; } - - UInt_t size = sizeof(AliHLTTPCDigitData)*ndigitcount + // Matthias 05.11.2007 + // The question is whether we should always return a AliHLTTPCDigitRowData + // for each row, even the empty ones or only for the ones filled with data. + // the AliHLTTPCDigitReaderUnpacked as the counnterpart so far assumes + // empty RawData structs for empty rows. But some of the code here implies + // the latter approach, e.g. the count of nrows in the loop above (now + // commented). At least the two loops were not consistent, it's fixed now. + nrows=fRowMax-fRowMin+1; + + UInt_t bufferSize = sizeof(AliHLTTPCDigitData)*ndigitcount + nrows*sizeof(AliHLTTPCDigitRowData); LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliDigits2Memory","Digits") - <0) { - if (size<=*pTgtSize) { + if (bufferSize<=*pTgtSize) { data=reinterpret_cast(tgtBuffer); } else { } - } else { - data=reinterpret_cast(Allocate(size)); + } else if (bufferSize>0) { + data=reinterpret_cast(Allocate(bufferSize)); + } + if (pTgtSize) *pTgtSize=bufferSize; + if (data==NULL) { + delete [] ndigits; + return NULL; } - if (pTgtSize) *pTgtSize=size; - if (data==NULL) return NULL; nrow = (UInt_t)nrows; AliHLTTPCDigitRowData *tempPt = data; + memset(data, 0, bufferSize); for(Int_t r=fRowMin;r<=fRowMax;r++){ Int_t n=fIndex[fSlice][r]; - tempPt->fRow = r; + + AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row); + tempPt->fRow = row; tempPt->fNDigit = 0; if(n!=-1){//data on that row + Int_t lslice,lrow; fDigitsTree->GetEvent(n); fParam->AdjustSectorRow(fDigits->GetID(),sector,row); AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row); @@ -550,6 +568,8 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int continue; } + // set the correct row no and digit count + tempPt->fRow = row; tempPt->fNDigit = ndigits[lrow]; Int_t localcount=0; @@ -580,13 +600,15 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int tempPt->fDigitData[localcount].fTrackID[2] = fDigits->GetTrackID(time,pad,2); localcount++; } while (fDigits->Next()); - Byte_t *tmp = (Byte_t*)tempPt; - Int_t size = sizeof(AliHLTTPCDigitRowData) - + ndigits[lrow]*sizeof(AliHLTTPCDigitData); - tmp += size; - tempPt = (AliHLTTPCDigitRowData*)tmp; } + + Byte_t *tmp = (Byte_t*)tempPt; + Int_t blockSize = sizeof(AliHLTTPCDigitRowData) + + tempPt->fNDigit*sizeof(AliHLTTPCDigitData); + tmp += blockSize; + tempPt = (AliHLTTPCDigitRowData*)tmp; } + assert((Byte_t*)tempPt==((Byte_t*)data)+bufferSize); delete [] ndigits; return data; } diff --git a/HLT/TPCLib/AliHLTTPCLog.h b/HLT/TPCLib/AliHLTTPCLog.h index e9aa393a255..ae056ea287a 100644 --- a/HLT/TPCLib/AliHLTTPCLog.h +++ b/HLT/TPCLib/AliHLTTPCLog.h @@ -33,7 +33,7 @@ using namespace std; */ class AliHLTTPCLog { public: - enum TLogLevel { kNone = 0, kDebug= 0x01, kInformational = 0x02, kWarning = 0x04, kError = 0x08 , kFatal = 0x10, kPrimary = 0x80, kAll = 0x9F }; + enum TLogLevel { kNone = 0, kBenchmark=0x01,kDebug= 0x02, kInformational = 0x04, kWarning = 0x08, kError = 0x10 , kFatal = 0x20, kPrimary = 0x80, kAll = 0xBF }; /** not used */ static const char* kEnd; //! transient diff --git a/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx b/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx index e4b2aed6648..d18af9729b0 100644 --- a/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx +++ b/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx @@ -684,6 +684,8 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evt "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.", ntracks0, slice, minPatch, maxPatch, row[0], row[1] ); + fTracker->Reset(); + tSize += mysize+sizeof(AliHLTTPCTrackletData); outBPtr += mysize+sizeof(AliHLTTPCTrackletData); diff --git a/HLT/TPCLib/AliHLTTPCTrackArray.cxx b/HLT/TPCLib/AliHLTTPCTrackArray.cxx index 024a8d544d1..55ffa213e23 100644 --- a/HLT/TPCLib/AliHLTTPCTrackArray.cxx +++ b/HLT/TPCLib/AliHLTTPCTrackArray.cxx @@ -131,6 +131,7 @@ void AliHLTTPCTrackArray::DeleteArray() delete fTrack[i]; delete[] fIsPresent; delete[] fTrack; + fSize=0; } Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize) diff --git a/HLT/TPCLib/AliHLTTPCTrackArray.h b/HLT/TPCLib/AliHLTTPCTrackArray.h index 34ca5f0d3d9..1f6e65c7a9d 100644 --- a/HLT/TPCLib/AliHLTTPCTrackArray.h +++ b/HLT/TPCLib/AliHLTTPCTrackArray.h @@ -80,6 +80,11 @@ class AliHLTTPCTrackArray { Int_t GetNPresent() const {return (fNTracks- fNAbsent);} Int_t GetNTracks() const {return fNTracks;} + + /** + * Return pointer to next free track object. + * The array is grown if necessary. + */ AliHLTTPCTrack *NextTrack(); AliHLTTPCTrack *GetCheckedTrack(Int_t t){if(fIsPresent[t]) return fTrack[t]; return 0;} AliHLTTPCTrack *GetTrack(Int_t t){return fTrack[t];} @@ -120,7 +125,7 @@ class AliHLTTPCTrackArray { AliHLTTPCTrackArray& operator=(const AliHLTTPCTrackArray&); Char_t fTrackType; //track type - Int_t fSize; //size of arra + Int_t fSize; //size of array Bool_t *fIsPresent;//! Int_t fNAbsent; //ntracks absent diff --git a/HLT/TPCLib/AliHLTTPCTransform.cxx b/HLT/TPCLib/AliHLTTPCTransform.cxx index bc015fa4cde..34c5604c60a 100644 --- a/HLT/TPCLib/AliHLTTPCTransform.cxx +++ b/HLT/TPCLib/AliHLTTPCTransform.cxx @@ -1746,7 +1746,8 @@ Double_t AliHLTTPCTransform::GetPhi(Float_t *xyz) Bool_t AliHLTTPCTransform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row) { - //slice to sector number + //slice no to sector number + //row no to local sector row no if(slicerow<0&&slicerow>=fgNRow){ LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Slice2Sector","Slicerow") <SetAliInput(pRunLoader)) { @@ -175,7 +175,7 @@ int AliHLTTPCDigitPublisherComponent::DoDeinit() fpFileHandler->FreeDigitsTree(); fCurrEvent=-1; } - //HLTInfo("publisher %p: %d references to file handler instance", this, fFileHandlerInstances); + //HLTDebug("publisher %p: %d references to file handler instance", this, fFileHandlerInstances); if (--fFileHandlerInstances==0 && fpFileHandler!=NULL) { try { if (fpFileHandler) { @@ -211,14 +211,15 @@ int AliHLTTPCDigitPublisherComponent::GetEvent(const AliHLTComponentEventData& e UInt_t nrow=0; UInt_t tgtSize=size-sizeof(AliHLTTPCUnpackedRawData); if (fCurrEvent>=0 && fCurrEvent!=event) { - HLTInfo("new event %d, free digit tree for event %d", event, fCurrEvent); + HLTDebug("new event %d, free digit tree for event %d", event, fCurrEvent); fpFileHandler->FreeDigitsTree(); } fCurrEvent=event; - fpFileHandler->Init(fMinSlice,fMinPart); + HLTDebug("converting digits for slice %d partition %d", fMinSlice, fMinPart); + fpFileHandler->Init(fMinSlice,fMinPart); AliHLTTPCDigitRowData* pData=fpFileHandler->AliDigits2Memory(nrow, event, reinterpret_cast(pTgt->fDigits), &tgtSize); if (pData==NULL && tgtSize>0 && tgtSize>fMaxSize) { - HLTInfo("target buffer too small: %d byte required, %d available", tgtSize+sizeof(AliHLTTPCUnpackedRawData), size); + HLTDebug("target buffer too small: %d byte required, %d available", tgtSize+sizeof(AliHLTTPCUnpackedRawData), size); // indicate insufficient buffer size, on occasion the frameworks calls // again with the corrected buffer fMaxSize=tgtSize; @@ -236,6 +237,7 @@ int AliHLTTPCDigitPublisherComponent::GetEvent(const AliHLTComponentEventData& e bd.fSize = size; bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(fMinSlice, fMinSlice, fMinPart, fMinPart); outputBlocks.push_back( bd ); + HLTDebug("added AliHLTTPCUnpackedRawData size %d, first row %d nof digits %d", size, pTgt->fDigits->fRow, pTgt->fDigits->fNDigit); } } } else { -- 2.43.0