// @(#) $Id$
-
-/** \class AliHLTTPCConfMapper
-<pre>
-//_____________________________________________________________
-// AliHLTTPCConfMapper
-//
-// Conformal mapping base class
-//
-// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
-// Copyright © ALICE HLT Group
-</pre>
+// Original: AliHLTConfMapper.cxx,v 1.26 2005/06/14 10:55:21 cvetan Exp $
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* *
+//* Primary Authors: Anders Vestbo, maintained by
+//* Matthias Richter <Matthias.Richter@ift.uib.no> *
+//* for The ALICE HLT Project. *
+//* *
+//* Permission to use, copy, modify and distribute this software and its *
+//* documentation strictly for non-commercial purposes is hereby granted *
+//* without fee, provided that the above copyright notice appears in all *
+//* copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************
+
+/** @file AliHLTTPCConfMapper.cxx
+ @author Anders Vestbo, Matthias Richter
+ @date Conformal mapping base class.
+ @brief
*/
+#include <cassert>
#include <sys/time.h>
-#include "AliHLTTPCStandardIncludes.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCLogging.h"
ClassImp(AliHLTTPCConfMapper)
AliHLTTPCConfMapper::AliHLTTPCConfMapper()
+ :
+ fBench(kTRUE),
+ fNTracks(0),
+ fVertex(NULL),
+ fVertexFinder(kFALSE),
+ fHit(),
+ fTrack(NULL),
+ fMaxDca(0.0), // no clue whether this is reasonable, but at least better than without initialization
+ fVolume(NULL),
+ fRow(NULL),
+ fNumRowSegment(0),
+ fNumPhiSegment(0),
+ fNumEtaSegment(0),
+ fNumRowSegmentPlusOne(0),
+ fNumPhiSegmentPlusOne(0),
+ fNumEtaSegmentPlusOne(0),
+ fNumPhiEtaSegmentPlusOne(0),
+ fBounds(0),
+ fPhiHitsOutOfRange(0),
+ fEtaHitsOutOfRange(0),
+ fPhiMin(0),
+ fPhiMax(0),
+ fEtaMin(0),
+ fEtaMax(0),
+ fRowMin(0),
+ fRowMax(0),
+ fVertexConstraint(kTRUE),
+ fGoodDist(0.0),
+ fMaxPhi(0.0),
+ fMaxEta(0.0),
+ fMainVertexTracks(0),
+ fClustersUnused(0),
+ fClusterCutZ(-1)
{
//Default constructor
- fVertex = NULL;
- fTrack = NULL;
- fHit = NULL;
- fVolume = NULL;
- fRow = NULL;
- fBench = (Bool_t)true;
- fVertexConstraint = (Bool_t)true;
fParamSet[0]=0;
fParamSet[1]=0;
}
-
AliHLTTPCConfMapper::~AliHLTTPCConfMapper()
{
// Destructor.
- if(fVolume) {
- delete [] fVolume;
- }
if(fRow) {
delete [] fRow;
}
- if(fHit) {
- delete [] fHit;
- }
if(fTrack) {
delete fTrack;
}
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::kInformational,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
- "Allocating "<<fBounds*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fVolume"<<ENDLOG;
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
- "Allocating "<<fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fRow"<<ENDLOG;
-
- fVolume = new AliHLTTPCConfMapContainer[fBounds];
- fRow = new AliHLTTPCConfMapContainer[fNumRowSegmentPlusOne];
-
- memset(fVolume,0,fBounds*sizeof(AliHLTTPCConfMapContainer));
- memset(fRow,0,fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer));
-
- Int_t maxnumoftracks = 2000;
- Int_t maxnumofhits = 120000;
-
- if(fHit)
- delete [] fHit;
- if(fTrack)
- delete fTrack;
-
- fHit = new AliHLTTPCConfMapPoint[maxnumofhits];
- fTrack = new AliHLTTPCTrackArray("AliHLTTPCConfMapTrack",maxnumoftracks);
+ fClustersUnused=0;
+ fHit.clear();
}
void AliHLTTPCConfMapper::InitSector(Int_t sector,Int_t *rowrange,Float_t *etarange)
}
Bool_t AliHLTTPCConfMapper::ReadHits(UInt_t count, AliHLTTPCSpacePointData* hits )
+{
+ //read hits with ReadHitsChecked
+ return ReadHitsChecked(count,hits,0);
+}
+
+Bool_t AliHLTTPCConfMapper::ReadHitsChecked(UInt_t count, AliHLTTPCSpacePointData* hits, unsigned int sizeInByte )
{
//read hits
- Int_t nhit=(Int_t)count;
- for (Int_t i=0;i<nhit;i++)
- {
- fHit[i+fClustersUnused].Reset();
- fHit[i+fClustersUnused].ReadHits(&(hits[i]));
- }
- fClustersUnused += nhit;
+ if(fClusterCutZ == -1){
+ if (fHit.size()<fClustersUnused+count) fHit.resize(fClustersUnused+count);
+ assert(fHit.size()>=fClustersUnused+count);
+ for (Int_t i=0;(UInt_t)i<count;i++)
+ {
+ AliHLTTPCSpacePointData *hit = &hits[i];
+ if (sizeInByte>0 && ((AliHLTUInt8_t*)hit)+sizeof(AliHLTTPCSpacePointData)>((AliHLTUInt8_t*)hits)+sizeInByte) {
+ LOG(AliHLTTPCLog::kWarning,"AliHLTTPCConfMapper::ReadHits","")<<"Wrong size of data (" << sizeInByte << " byte), skipping array of AliHLTTPCSpacePointData" <<ENDLOG;;
+ break;
+ }
+ fHit[i+fClustersUnused].Reset();
+ fHit[i+fClustersUnused].Read(hits[i]);
+ }
+ fClustersUnused += count;
+ }
+ else{
+ //Skipping clusters with high Z.
+ UInt_t skipped=0;
+
+ if (fHit.size()<fClustersUnused+count) fHit.resize(fClustersUnused+count);
+ assert(fHit.size()>=fClustersUnused+count);
+ for (Int_t i=0;(UInt_t)i<count;i++)
+ {
+ AliHLTTPCSpacePointData *hit = &hits[i];
+ if (sizeInByte>0 && ((AliHLTUInt8_t*)hit)+sizeof(AliHLTTPCSpacePointData)>((AliHLTUInt8_t*)hits)+sizeInByte) {
+ LOG(AliHLTTPCLog::kWarning,"AliHLTTPCConfMapper::ReadHits","")<<"Wrong size of data (" << sizeInByte << " byte), skipping array of AliHLTTPCSpacePointData" <<ENDLOG;;
+ break;
+ }
+ if(hits[i].fZ > fClusterCutZ || hits[i].fZ < -1*fClusterCutZ){
+ ++skipped;
+ continue;
+ }
+ fHit[i+fClustersUnused-skipped].Reset();
+ fHit[i+fClustersUnused-skipped].Read(hits[i]);
+ }
+ fClustersUnused += count - skipped;
+ fHit.resize(fClustersUnused);
+ }
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::ReadHits","#hits")
- <<AliHLTTPCLog::kDec<<"hit_counter: "<<nhit<<" count: "<<count<<ENDLOG;
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::ReadHits","#hits")
+ <<AliHLTTPCLog::kDec<<"#hits: "<<count<<" total: "<<fClustersUnused<<ENDLOG;
return true;
}
if(fClustersUnused < fMinPoints[fVertexConstraint])
return;
- //Reset detector volumes
+ //Allocate detector volumes
+ if (fVolume==NULL) {
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
+ "Allocating "<<fBounds*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fVolume"<<ENDLOG;
+ fVolume = new AliHLTTPCConfMapContainer[fBounds];
+ }
+
+ if (fRow==NULL) {
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::InitVolumes","Memory")<<AliHLTTPCLog::kDec<<
+ "Allocating "<<fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer)<<" Bytes to fRow"<<ENDLOG;
+ fRow = new AliHLTTPCConfMapContainer[fNumRowSegmentPlusOne];
+ }
+
memset(fVolume,0,fBounds*sizeof(AliHLTTPCConfMapContainer));
memset(fRow,0,fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer));
Int_t volumeIndex;
Int_t localcounter=0;
+ assert((int)fHit.size()>=fClustersUnused);
for(Int_t j=0; j<fClustersUnused; j++)
{
- //AliHLTTPCConfMapPoint *thisHit = (AliHLTTPCConfMapPoint*)fHit->At(j);
AliHLTTPCConfMapPoint *thisHit = &(fHit[j]);
thisHit->Setup(fVertex);
fRow[(localrow-fRowMin)].last = (void *)thisHit;
}
+ //If a cluster has an Eta outside the Eta or Phi range set in the Tracker, it will go in to
+ //the if here. This has been seen for high Eta clusters most likely from signal from the gating grid.
+ //These clusters are read in, but not used in the Tracking.
+#ifdef PACKAGE_STRING
if(fClustersUnused>0 && localcounter==0)
- LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Parameters")
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::SetPointers","Parameters")
<<AliHLTTPCLog::kDec<<"No points passed to track finder, hits out of range: "
<<fEtaHitsOutOfRange+fPhiHitsOutOfRange<<ENDLOG;
Int_t hits_accepted=fClustersUnused-(fEtaHitsOutOfRange+fPhiHitsOutOfRange);
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::SetPointers","Setup")
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::SetPointers","Setup")
<<"Setup finished, hits out of range: "<<fEtaHitsOutOfRange+fPhiHitsOutOfRange
<<" hits accepted "<<hits_accepted<<ENDLOG;
+#endif //PACKAGE_STRING
}
-void AliHLTTPCConfMapper::MainVertexTracking_a()
+void AliHLTTPCConfMapper::MainVertexTrackingA()
{
//Tracking with vertex constraint.
SetVertexConstraint(true);
cpuTime = CpuTime() - initCpuTime;
if(fBench)
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking_a","Timing")
+ LOG(AliHLTTPCLog::kBenchmark,"AliHLTTPCConfMapper::MainVertexTrackingA","Timing")
<<AliHLTTPCLog::kDec<<"Setup finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
}
-void AliHLTTPCConfMapper::MainVertexTracking_b()
+void AliHLTTPCConfMapper::MainVertexTrackingB()
{
//Tracking with vertex constraint.
cpuTime = CpuTime() - initCpuTime;
if(fBench)
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking_b","Timing")
+ LOG(AliHLTTPCLog::kBenchmark,"AliHLTTPCConfMapper::MainVertexTrackingB","Timing")
<<AliHLTTPCLog::kDec<<"Main Tracking finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
}
Double_t initCpuTime,cpuTime;
initCpuTime = CpuTime();
-// END ################################################# MODIFIY JMT
-#if 0
- SetPointers(); // moved to Component
-#endif
-// END ################################################# MODIFIY JMT
+
+ SetPointers();
+
SetVertexConstraint(true);
ClusterLoop();
cpuTime = CpuTime() - initCpuTime;
if(fBench)
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking","Timing")<<AliHLTTPCLog::kDec<<
+ LOG(AliHLTTPCLog::kBenchmark,"AliHLTTPCConfMapper::MainVertexTracking","Timing")<<AliHLTTPCLog::kDec<<
"Tracking finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
return;
}
SetVertexConstraint(false);
+
+ SetPointers(); //To be able to do only nonvertextracking (more testing)
+
ClusterLoop();
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::NonVertexTracking","ntracks")<<AliHLTTPCLog::kDec<<
"Number of nonvertex tracks found: "<<(fNTracks-fMainVertexTracks)<<ENDLOG;
"VolumeIndex error "<<volumeIndex<<ENDLOG;
}
+ assert(fVolume!=NULL);
for(hit = (AliHLTTPCConfMapPoint*)fVolume[volumeIndex].first;
hit!=0; hit = hit->GetNextVolumeHit())
{
if(track)//track search - look for nearest neighbor to extrapolated track
{
-// BEGINN ############################################## MODIFIY JMT
-#if 1
- if (fVertexConstraint) {
- if(!VerifyRange(starthit,hit))
- continue;
- }
-#else
- if(!VerifyRange(starthit,hit))
- continue;
-#endif
-// END ################################################# MODIFIY JMT
+ if (fVertexConstraint) {
+ if(!VerifyRange(starthit,hit))
+ continue;
+ }
testhit = EvaluateHit(starthit,hit,track);
if(testhit == 0)//chi2 not good enough, keep looking
if((dist=CalcDistance(starthit,hit)) < closestdist)
{
-// BEGINN ############################################## MODIFIY JMT
-#if 1
- if (fVertexConstraint) {
+ if (fVertexConstraint) {
if(!VerifyRange(starthit,hit))
- continue;
- }
-#else
- if(!VerifyRange(starthit,hit))
- continue;
-#endif
-// END ################################################# MODIFIY JMT
+ continue;
+ }
closestdist = dist;
closesthit = hit;
if(n<3)
return 0;
- Double_t x1[2];
- Double_t x2[2];
- Double_t x3[2];
+ Double_t x1[2]={0,0};
+ Double_t x2[2]={0,0};
+ Double_t x3[2]={0,0};
Double_t angle1,angle2;
Int_t counter=0;
for(track->StartLoop(); track->LoopDone(); track->GetNextHit())
Int_t numoftracks = fNTracks;
if(fNTracks == 0)
{
- LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::FillTracks","fNTracks")<<AliHLTTPCLog::kDec<<
+ LOG(AliHLTTPCLog::kDebug,"AliHLTTPCConfMapper::FillTracks","fNTracks")<<AliHLTTPCLog::kDec<<
"No tracks found!!"<<ENDLOG;
return 0;
}