STEERBase added to include path

[u/mrichter/AliRoot.git] / HLT / hough / AliHLTHoughEval.cxx

// @(#) $Id$

// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright &copy ALICE HLT Group

#include "AliHLTStandardIncludes.h"

#ifdef use_root
#include <TH1.h>
#include <TFile.h>
#endif

#include "AliHLTLogging.h"
#include "AliHLTHoughEval.h"
#include "AliHLTMemHandler.h"
#include "AliHLTTrackArray.h"
#include "AliHLTHoughBaseTransformer.h"
#include "AliHLTDigitData.h"
#include "AliHLTHoughTrack.h"
#include "AliHLTTransform.h"
#include "AliHLTHistogram.h"
#include "AliHLTHistogram1D.h"

#if __GNUC__ == 3
using namespace std;
#endif

/** /class AliHLTHoughEval
//<pre>
//_____________________________________________________________
// AliHLTHoughEval
//
// Evaluation class for tracklets produced by the Hough transform.
//
</pre>
*/

ClassImp(AliHLTHoughEval)

AliHLTHoughEval::AliHLTHoughEval()
{
  //default ctor  
  fRemoveFoundTracks = kFALSE;
  fNumOfPadsToLook = 1;
  fNumOfRowsToMiss = 1;
  fEtaHistos=0;
  fRowPointers = 0;
}


AliHLTHoughEval::~AliHLTHoughEval()
{
  //dtor
  fHoughTransformer = 0;
  if(fRowPointers)
    {
      for(Int_t i=0; i<fNrows; i++)
	fRowPointers[i] = 0;
      delete [] fRowPointers;
    }
}

void AliHLTHoughEval::InitTransformer(AliHLTHoughBaseTransformer *transformer)
{
  //Init hough transformer
  fHoughTransformer = transformer;
  fSlice = fHoughTransformer->GetSlice();
  fPatch = fHoughTransformer->GetPatch();
  fNrows = AliHLTTransform::GetLastRow(fPatch) - AliHLTTransform::GetFirstRow(fPatch) + 1;
  fNEtaSegments = fHoughTransformer->GetNEtaSegments();
  fEtaMin = fHoughTransformer->GetEtaMin();
  fEtaMax = fHoughTransformer->GetEtaMax();
  fZVertex = fHoughTransformer->GetZVertex();
  GenerateLUT();
}

void AliHLTHoughEval::GenerateLUT()
{
  //Generate a Look-up table, to limit the access to raw data
  
  if(!fRowPointers)
    fRowPointers = new AliHLTDigitRowData*[fNrows];

  AliHLTDigitRowData *tempPt = (AliHLTDigitRowData*)fHoughTransformer->GetDataPointer();
  if(!tempPt)
    printf("\nAliHLTHoughEval::GenerateLUT : Zero data pointer\n");
  
  for(Int_t i=AliHLTTransform::GetFirstRow(fPatch); i<=AliHLTTransform::GetLastRow(fPatch); i++)
    {
      Int_t prow = i - AliHLTTransform::GetFirstRow(fPatch);
      fRowPointers[prow] = tempPt;
      AliHLTMemHandler::UpdateRowPointer(tempPt);
    }
  
}

Bool_t AliHLTHoughEval::LookInsideRoad(AliHLTHoughTrack *track,Int_t &nrowscrossed,Int_t *rowrange,Bool_t remove)
{
  //Look at rawdata along the road specified by the track candidates.
  //If track is good, return true, if not return false.
  
  Int_t sector,row;
  
  Int_t nrow=0,npixs=0;//,rows_crossed=0;
  Float_t xyz[3];
  
  Int_t totalcharge=0;//total charge along the road
  
  //for(Int_t padrow = AliHLTTransform::GetFirstRow(fPatch); padrow <= AliHLTTransform::GetLastRow(fPatch); padrow++)
  for(Int_t padrow = rowrange[0]; padrow<=rowrange[1]; padrow++)
    {
      Int_t prow = padrow - AliHLTTransform::GetFirstRow(fPatch);
      if(track->IsHelix())
	{
	  if(!track->GetCrossingPoint(padrow,xyz))  
	    {
	      continue;
	    }
	}
      else
	{
	  track->GetLineCrossingPoint(padrow,xyz);
	  xyz[0] += AliHLTTransform::Row2X(track->GetFirstRow());
	  Float_t r = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
	  xyz[2] = r*track->GetTgl();
	}
      
      AliHLTTransform::Slice2Sector(fSlice,padrow,sector,row);
      AliHLTTransform::Local2Raw(xyz,sector,row);

      npixs=0;
      
      //Get the timebins for this pad
      AliHLTDigitRowData *tempPt = fRowPointers[prow];
      if(!tempPt) 
	{
	  printf("AliHLTHoughEval::LookInsideRoad : Zero data pointer\n");
	  continue;
	}
      
      //Look at both sides of the pad:
      for(Int_t p=(Int_t)rint(xyz[1])-fNumOfPadsToLook; p<=(Int_t)rint(xyz[1])+fNumOfPadsToLook; p++)
	{
	  AliHLTDigitData *digPt = tempPt->fDigitData;
	  for(UInt_t j=0; j<tempPt->fNDigit; j++)
	    {
	      Int_t pad = digPt[j].fPad;
	      Int_t charge = digPt[j].fCharge;
	      if(charge <= fHoughTransformer->GetLowerThreshold()) continue;
	      if(pad < p) continue;
	      if(pad > p) break;
	      UShort_t time = digPt[j].fTime;
	      Double_t eta = AliHLTTransform::GetEta(fSlice,padrow,pad,time);
	      Int_t pixelindex = fHoughTransformer->GetEtaIndex(eta);
	      if(pixelindex != track->GetEtaIndex()) continue;
	      totalcharge += digPt[j].fCharge;
	      if(remove)
		digPt[j].fCharge = 0; //Erease the track from image
	      npixs++;
	    }
	}
            
      if(npixs > 1)//At least 2 digits on this padrow
	{
	  nrow++;
	}	  
    }
  if(remove)
    return kTRUE;
  
  nrowscrossed += nrow; //Update the number of rows crossed.
  
  if(nrow >= rowrange[1]-rowrange[0]+1 - fNumOfRowsToMiss)//this was a good track
    {
      if(fRemoveFoundTracks)
	{
	  Int_t dummy=0;
	  LookInsideRoad(track,dummy,rowrange,kTRUE);
	}
      return kTRUE;
    }
  else
    return kFALSE;
}

void AliHLTHoughEval::FindEta(AliHLTTrackArray *tracks)
{
  //Find the corresponding eta slice hough space  
  Int_t sector,row;
  Float_t xyz[3];
  
  Int_t ntracks = tracks->GetNTracks();
  fEtaHistos = new AliHLTHistogram1D*[ntracks];
  
  Char_t hname[100];
  for(Int_t i=0; i<ntracks; i++)
    {
      sprintf(hname,"etahist_%d",i);
      fEtaHistos[i] = new AliHLTHistogram1D(hname,hname,100,0,1);
    }
  Double_t etaslice = (fEtaMax - fEtaMin)/fNEtaSegments;
  
  for(Int_t ntr=0; ntr<ntracks; ntr++)
    {
      AliHLTHoughTrack *track = (AliHLTHoughTrack*)tracks->GetCheckedTrack(ntr);
      if(!track) continue;
      for(Int_t padrow = AliHLTTransform::GetFirstRow(fPatch); padrow <= AliHLTTransform::GetLastRow(fPatch); padrow++)
	{
	  Int_t prow = padrow - AliHLTTransform::GetFirstRow(fPatch);
	  
	  if(!track->GetCrossingPoint(padrow,xyz))  
	    {
	      printf("AliHLTHoughEval::LookInsideRoad : Track does not cross line!!\n");
	      continue;
	    }
	  
	  AliHLTTransform::Slice2Sector(fSlice,padrow,sector,row);
	  AliHLTTransform::Local2Raw(xyz,sector,row);
	  
	  //Get the timebins for this pad
	  AliHLTDigitRowData *tempPt = fRowPointers[prow];
	  if(!tempPt) 
	    {
	      printf("AliHLTHoughEval::LookInsideRoad : Zero data pointer\n");
	      continue;
	    }
	  
	  //Look at both sides of the pad:
	  for(Int_t p=(Int_t)rint(xyz[1])-fNumOfPadsToLook; p<=(Int_t)rint(xyz[1])+fNumOfPadsToLook; p++)
	    {
	      AliHLTDigitData *digPt = tempPt->fDigitData;
	      for(UInt_t j=0; j<tempPt->fNDigit; j++)
		{
		  UChar_t pad = digPt[j].fPad;
		  Int_t charge = digPt[j].fCharge;
		  if(charge <= fHoughTransformer->GetLowerThreshold()) continue;
		  if(pad < p) continue;
		  if(pad > p) break;
		  UShort_t time = digPt[j].fTime;
		  Double_t eta = AliHLTTransform::GetEta(fSlice,padrow,pad,time);
		  Int_t pixelindex = (Int_t)(eta/etaslice);
		  if(pixelindex > track->GetEtaIndex()+1) continue;
		  if(pixelindex < track->GetEtaIndex()-1) break;
		  fEtaHistos[ntr]->Fill(eta,digPt[j].fCharge);
		}
	    }
	}
    }
  
  for(Int_t i=0; i<ntracks; i++)
    {
      AliHLTHistogram1D *hist = fEtaHistos[i];
      Int_t maxbin = hist->GetMaximumBin();
      Double_t maxvalue = hist->GetBinContent(maxbin);
      AliHLTHoughTrack *track = (AliHLTHoughTrack*)tracks->GetCheckedTrack(i);
      if(!track) continue;
      if(hist->GetBinContent(maxbin-1)<maxvalue && hist->GetBinContent(maxbin+1)<maxvalue)
	{
	  track->SetWeight((Int_t)maxvalue,kTRUE); 
	  track->SetEta(hist->GetBinCenter(maxbin));
	  track->SetNHits(track->GetWeight());
	}
      else
	{
	  track->SetWeight(0);
	  tracks->Remove(i); //remove this track, because it was not a peak
	}    
    }
  tracks->Compress();
  
  //for(Int_t i=0; i<ntracks; i++)
  //delete fEtaHistos[i];