[u/mrichter/AliRoot.git] / TRD / AliTRDtrackingChamber.cxx

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* 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.                  *
**************************************************************************/

/* $Id: AliTRDtrackingChamber.cxx 23810 2008-02-08 09:00:27Z hristov $ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  Tracking in one chamber                                               //
//                                                                        //
//  Authors:                                                              //
//    Alex Bercuci <A.Bercuci@gsi.de>                                     //
//    Markus Fasel <M.Fasel@gsi.de>                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "AliTRDtrackingChamber.h"

#include "TMath.h"
#include "TMatrixTBase.h"
#include <TTreeStream.h>

#include "AliTRDReconstructor.h"
#include "AliTRDrecoParam.h"
#include "AliTRDtrackerV1.h"
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcalibDB.h"
#include "AliTRDCommonParam.h"
#include "Cal/AliTRDCalDet.h"
#include "Cal/AliTRDCalROC.h"

ClassImp(AliTRDtrackingChamber)

//_______________________________________________________
AliTRDtrackingChamber::AliTRDtrackingChamber() 
  :TObject()
  ,fDetector(-1)
  ,fX0(0.)
  // ,fExB(0.)
  // ,fVD(0.)
  // ,fT0(0.)
  // ,fS2PRF(0.)
  // ,fDiffL(0.)
  // ,fDiffT(0.)
{}  

//_______________________________________________________
void AliTRDtrackingChamber::Clear(const Option_t *opt)
{
  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++) fTB[itb].Clear(opt);
}

//_______________________________________________________
Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *const geo, Bool_t hlt)
{
// Init chamber and all time bins (AliTRDchamberTimeBin)
// Calculates radial position of the chamber based on 
// radial positions of the time bins (calibration/alignment aware)
//
  if(fDetector < 0 || fDetector >= AliTRDgeometry::kNdet){
    AliWarning(Form("Detector index not set correctly to %d", fDetector));
    return kFALSE;
  }

  Int_t stack = AliTRDgeometry::GetStack(fDetector);
  Int_t layer = AliTRDgeometry::GetLayer(fDetector);
  AliTRDpadPlane *pp = geo->GetPadPlane(layer, stack);
  Double_t zl = pp->GetRow0ROC() - pp->GetRowEndROC();
  Double_t z0 = geo->GetRow0(layer, stack, 0) - zl;
  Int_t nrows = pp->GetNrows();
  
  Int_t index[50], jtb = 0;
  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
    if(!fTB[itb]) continue;
    fTB[itb].SetRange(z0, zl);
    fTB[itb].SetNRows(nrows);
    fTB[itb].SetPlane(layer);
    fTB[itb].SetStack(stack);
    fTB[itb].SetSector(AliTRDgeometry::GetSector(fDetector));
    fTB[itb].BuildIndices();
    index[jtb++] = itb;
  }	
  if(jtb<2) return kFALSE;

  AliTRDcalibDB *calib = AliTRDcalibDB::Instance();
  Float_t t0;
  if(!hlt){
    t0    = calib->GetT0Average(fDetector);
  }else{
    t0    = calib->GetT0Det()->GetValue(fDetector);
  }
  // fVD    = calib->GetVdriftAverage(fDetector);
  // fS2PRF = calib->GetPRFROC(fDetector)->GetMean(); fS2PRF *= fS2PRF;
  // fExB   = AliTRDCommonParam::Instance()->GetOmegaTau(fVD);
  // AliTRDCommonParam::Instance()->GetDiffCoeff(fDiffL, fDiffT, fVD);  

  // ESTIMATE POSITION OF PAD PLANE FOR THIS CHAMBER
  //fTB[Int_t(t0)].SetT0();
  Double_t x0 = fTB[index[0]].GetX();
  Double_t x1 = fTB[index[1]].GetX();
  Double_t dx = (x0 - x1)/(index[1] - index[0]); 
  fX0 = x0 + dx*(index[0] - t0);	
  return kTRUE;
}

//_______________________________________________________	
Int_t AliTRDtrackingChamber::GetNClusters() const
{
// Basic loop method
// Returns number of clusters in chamber
//
  Int_t n = 0;
  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
    n += Int_t(fTB[itb]);
  }
  return n;	
}	

//_______________________________________________________
void AliTRDtrackingChamber::Bootstrap(const AliTRDReconstructor *rec)
{
// Basic loop method
// Bootstrap each time bin
//
  AliTRDchamberTimeBin *jtb = &fTB[0];
  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
    (*jtb).Bootstrap(rec, fDetector);
  }
}

//_______________________________________________________
void  AliTRDtrackingChamber::SetOwner()
{
// Basic loop method
// Set ownership in time bins
//
  AliTRDchamberTimeBin *jtb = &fTB[0];
  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
    if(!(Int_t(*jtb))) continue;
    (*jtb).SetOwner();
  }
}

//_______________________________________________________
Double_t AliTRDtrackingChamber::GetQuality()
{
  //
  // Calculate chamber quality for seeding.
  // 
  //
  // Parameters :
  //   layers : Array of propagation layers for this plane.
  //
  // Output :
  //   plane quality factor for seeding
  // 
  // Detailed description
  //
  // The quality of the plane for seeding is higher if:
  //  1. the average timebin population is closer to an integer number
  //  2. the distribution of clusters/timebin is closer to a uniform distribution.
  //    - the slope of the first derivative of a parabolic fit is small or
  //    - the slope of a linear fit is small
  //

  Int_t ncl   = 0;
  Int_t nused = 0;
  Int_t nClLayer;
  for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
    if(!(nClLayer = fTB[itb].GetNClusters())) continue;
    ncl += nClLayer;
    for(Int_t incl = 0; incl < nClLayer; incl++){
      if((fTB[itb].GetCluster(incl))->IsUsed()) nused++;
    }
  }
  
  // calculate the deviation of the mean number of clusters from the
  // closest integer values
  Float_t nclMed = float(ncl-nused)/AliTRDtrackerV1::GetNTimeBins();
  Int_t ncli = Int_t(nclMed);
  Float_t nclDev = TMath::Abs(nclMed - TMath::Max(ncli, 1));
  nclDev -= (nclDev>.5) && ncli ? 1. : 0.;
  return TMath::Exp(-5.*TMath::Abs(nclDev));

// 	// get slope of the derivative
// 	if(!fitter.Eval()) return quality;
// 	fitter.PrintResults(3);
// 	Double_t a = fitter.GetParameter(1);
// 
// 	printf("ncl_dev(%f)  a(%f)\n", ncl_dev, a);
// 	return quality*TMath::Exp(-a);

}


//_______________________________________________________
Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec)
{
  //
  // Creates a seeding layer
  //
  
  // constants
  const Int_t kMaxRows = 16;
  const Int_t kMaxCols = 144;
  const Int_t kMaxPads = 2304;
  Int_t timeBinMin = rec->GetRecoParam()->GetNumberOfPresamples();
  Int_t timeBinMax = rec->GetRecoParam()->GetNumberOfPostsamples();

  // Get the geometrical data of the chamber
  Int_t layer = geo->GetLayer(fDetector);
  Int_t stack = geo->GetStack(fDetector);
  Int_t sector= geo->GetSector(fDetector);
  AliTRDpadPlane *pp = geo->GetPadPlane(layer, stack);
  Int_t nCols = pp->GetNcols();
  Float_t ymin = TMath::Min(pp->GetCol0(), pp->GetColEnd());
  Float_t ymax = TMath::Max(pp->GetCol0(), pp->GetColEnd());
  Float_t zmin = TMath::Min(pp->GetRow0(), pp->GetRowEnd());
  Float_t zmax = TMath::Max(pp->GetRow0(), pp->GetRowEnd());
  Float_t z0 = -1., zl = -1.;
  Int_t nRows = pp->GetNrows();
  Float_t binlength = (ymax - ymin)/nCols; 
  //AliInfo(Form("ymin(%f) ymax(%f) zmin(%f) zmax(%f) nRows(%d) binlength(%f)", ymin, ymax, zmin, zmax, nRows, binlength));
  
  // Fill the histogram
  Int_t nClusters;	
  Int_t *histogram[kMaxRows];											// 2D-Histogram
  Int_t hvals[kMaxPads + 1];	memset(hvals, 0, sizeof(Int_t)*kMaxPads);	 // one entry in addition for termination flag
  Float_t *sigmas[kMaxRows];
  Float_t svals[kMaxPads];	memset(svals, 0, sizeof(Float_t)*kMaxPads);	
  AliTRDcluster *c = NULL;
  for(Int_t irs = 0; irs < kMaxRows; irs++){
    histogram[irs] = &hvals[irs*kMaxCols];
    sigmas[irs] = &svals[irs*kMaxCols];
  }
  for(Int_t iTime = timeBinMin; iTime < AliTRDseedV1::kNtb-timeBinMax; iTime++){
    if(!(nClusters = fTB[iTime].GetNClusters())) continue;
    z0 = fTB[iTime].GetZ0();
    zl = fTB[iTime].GetDZ0();
    for(Int_t incl = 0; incl < nClusters; incl++){
      c = fTB[iTime].GetCluster(incl);	
      histogram[c->GetPadRow()][c->GetPadCol()]++;
      sigmas[c->GetPadRow()][c->GetPadCol()] += c->GetSigmaZ2();
    }
  }
  
// Now I have everything in the histogram, do the selection
  //Int_t nPads = nCols * nRows;
  // This is what we are interested in: The center of gravity of the best candidates
  Float_t cogyvals[kMaxPads]; memset(cogyvals, 0, sizeof(Float_t)*kMaxPads);
  Float_t cogzvals[kMaxPads]; memset(cogzvals, 0, sizeof(Float_t)*kMaxPads);
  Float_t *cogy[kMaxRows];
  Float_t *cogz[kMaxRows];
  
  // Lookup-Table storing coordinates according to the bins
  Float_t yLengths[kMaxCols]; memset(yLengths, 0, kMaxCols*sizeof(Float_t));
  Float_t zLengths[kMaxRows]; memset(zLengths, 0, kMaxRows*sizeof(Float_t));
  for(Int_t icnt = 0; icnt < nCols; icnt++){
    yLengths[icnt] = pp->GetColPos(nCols - 1 - icnt) + binlength/2;
  }
  for(Int_t icnt = 0; icnt < nRows; icnt++){
    zLengths[icnt] = pp->GetRowPos(icnt) - pp->GetRowSize(icnt)/2;
  }

  // A bitfield is used to mask the pads as usable
  Short_t mask[kMaxCols]; memset(mask, 0 ,sizeof(Short_t) * kMaxCols);//bool mvals[kMaxPads];
  for(UChar_t icount = 0; icount < nRows; icount++){
    cogy[icount] = &cogyvals[icount*kMaxCols];
    cogz[icount] = &cogzvals[icount*kMaxCols];
  }
  // In this array the array position of the best candidates will be stored
  Int_t   cand[AliTRDtrackerV1::kMaxTracksStack];
  Float_t sigcands[AliTRDtrackerV1::kMaxTracksStack];
  
  // helper variables
  Int_t indices[kMaxPads]; memset(indices, -1, sizeof(Int_t)*kMaxPads);
  Int_t nCandidates = 0;
  Float_t norm, cogv;
  // histogram filled -> Select best bins
  Int_t nPads = nCols * nRows;
  // take out all the bins which have less than 3 entries (faster sorting)
  Int_t content[kMaxPads], dictionary[kMaxPads], nCont = 0, padnumber = 0;
  Int_t *iter = &hvals[0], *citer = &content[0], *diter =  &dictionary[0]; // iterators for preselection
  const Int_t threshold = 2;
  hvals[nPads] = -1; // termination for iterator
  do{
    if(*iter > threshold){
      *(citer++) = *iter;
      *(diter++) = padnumber;
      nCont++;
    }
    padnumber++;
  }while(*(++iter) != -1);
  TMath::Sort(nCont, content, indices);		

  Int_t col, row, lower, lower1, upper, upper1;
  for(Int_t ib = 0; ib < nCont; ib++){
    if(nCandidates >= AliTRDtrackerV1::kMaxTracksStack){
      AliDebug(1, Form("Number of seed candidates %d exceeded maximum allowed per stack %d", nCandidates, AliTRDtrackerV1::kMaxTracksStack));
      break;
    }
    // Positions
    row = dictionary[indices[ib]]/nCols;
    col = dictionary[indices[ib]]%nCols;
    // here will be the threshold condition:
    if((mask[col] & (1 << row)) != 0) continue;		// Pad is masked: continue
    //	if(histogram[row][col] < TMath::Max(threshold, 1)){	// of course at least one cluster is needed
    //		break;			// number of clusters below threshold: break;
    //	} 
    // passing: Mark the neighbors
    lower  = TMath::Max(col - 1, 0); upper  = TMath::Min(col + 2, nCols);
    lower1 = TMath::Max(row - 1, 0); upper1 = TMath::Min(row + 2, nCols);
    for(Int_t ic = lower; ic < upper; ++ic)
      for(Int_t ir = lower1; ir < upper1; ++ir){
        if(ic == col && ir == row) continue;
        mask[ic] |= (1 << ir);
      }
    // Storing the position in an array
    // testing for neigboring
    cogv = 0;
    norm = 0;
    lower = TMath::Max(col - 1, 0);
    upper = TMath::Min(col + 2, nCols);
    for(Int_t inb = lower; inb < upper; ++inb){
      cogv += yLengths[inb] * histogram[row][inb];
      norm += histogram[row][inb];
    }
    cogy[row][col] = cogv / norm;
    cogv = 0; norm = 0;
    lower = TMath::Max(row - 1, 0);
    upper = TMath::Min(row + 2, nRows);
    for(Int_t inb = lower; inb < upper; ++inb){
      cogv += zLengths[inb] * histogram[inb][col];
      norm += histogram[inb][col];
    }
    cogz[row][col] = Float_t(cogv) /  norm;
    // passed the filter
    cand[nCandidates] = row*nCols + col;	// store the position of a passig candidate into an Array
    sigcands[nCandidates] = sigmas[row][col] / histogram[row][col]; // never be a floating point exeption
    // Analysis output
    nCandidates++;
  }
  if(!nCandidates) return kFALSE;
  
  Float_t pos[3], sig[2];
  Short_t signal[7]; memset(&signal[0], 0, 7*sizeof(Short_t));
  
  new(fakeLayer) AliTRDchamberTimeBin(layer, stack, sector, z0, zl);
  fakeLayer->SetReconstructor(rec);
  fakeLayer->SetNRows(nRows);
  fakeLayer->SetOwner(kFALSE);
  if(nCandidates){
    UInt_t fakeIndex = 0;
    for(Int_t ican = 0; ican < nCandidates; ican++){
      row = cand[ican] / nCols;
      col = cand[ican] % nCols;
      //temporary
      Int_t n = 0; Double_t x = 0., y = 0., z = 0.;
      for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
        if(!(nClusters = fTB[itb].GetNClusters())) continue;
        for(Int_t incl = 0; incl < nClusters; incl++){
          c = fTB[itb].GetCluster(incl);	
          if(c->GetPadRow() != row) continue;
          if(TMath::Abs(c->GetPadCol() - col) > 2) continue;
          x += c->GetX();
          y += c->GetY();
          z += c->GetZ();
          n++;
        }
      }
      if(!n) continue;
      pos[0] = x/n;
      pos[1] = y/n;
      pos[2] = z/n;
      sig[0] = .02;
      sig[1] = sigcands[ican];
      fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
    }
  }
  fakeLayer->BuildIndices();
  //fakeLayer->Print();
  
  if(rec->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 3){
    //TMatrixD hist(nRows, nCols);
    //for(Int_t i = 0; i < nRows; i++)
    //	for(Int_t j = 0; j < nCols; j++)
    //		hist(i,j) = histogram[i][j];
    TTreeSRedirector &cstreamer = *rec->GetDebugStream(AliTRDrecoParam::kTracker);
    cstreamer << "GetSeedingLayer"
    << "layer="      << layer
    << "ymin="       << ymin
    << "ymax="       << ymax
    << "zmin="       << zmin
    << "zmax="       << zmax
    << "L.="         << fakeLayer
    //<< "Histogram.=" << &hist
    << "\n";
  }
  
  return kTRUE;
}


//_______________________________________________________
void AliTRDtrackingChamber::Print(Option_t *opt) const
{
  // Print the chamber status
  if(!GetNClusters()) return;
  AliInfo(Form("fDetector   = %d", fDetector));
  AliInfo(Form("fX0         = %7.3f", fX0));
  const AliTRDchamberTimeBin *itb = &fTB[0];
  for(Int_t jtb=0; jtb<AliTRDseedV1::kNtb; jtb++, itb++) (*itb).Print(opt);
}


//_______________________________________________________
void AliTRDtrackingChamber::Update()
{
// Steer purging of used and shared clusters 

  AliTRDchamberTimeBin *jtb = &fTB[0];
  for(Int_t itb=AliTRDseedV1::kNtb; itb--; ++jtb){ 
    if(!(Int_t(*jtb))) continue;
    (*jtb).BuildIndices();
  }
}
Commit	Line	Data
b0a48c4d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id: AliTRDtrackingChamber.cxx 23810 2008-02-08 09:00:27Z hristov $ */
	17
	18	////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Tracking in one chamber //
	21	// //
	22	// Authors: //
	23	// Alex Bercuci <A.Bercuci@gsi.de> //
	24	// Markus Fasel <M.Fasel@gsi.de> //
	25	// //
	26	////////////////////////////////////////////////////////////////////////////
	27
	28	#include "AliTRDtrackingChamber.h"
	29
	30	#include "TMath.h"
	31	#include "TMatrixTBase.h"
	32	#include <TTreeStream.h>
	33
	34	#include "AliTRDReconstructor.h"
	35	#include "AliTRDrecoParam.h"
	36	#include "AliTRDtrackerV1.h"
	37	#include "AliTRDgeometry.h"
	38	#include "AliTRDpadPlane.h"
	39	#include "AliTRDcalibDB.h"
c79857d5	40	#include "AliTRDCommonParam.h"
b0a48c4d	41	#include "Cal/AliTRDCalDet.h"
	42	#include "Cal/AliTRDCalROC.h"
	43
	44	ClassImp(AliTRDtrackingChamber)
	45
	46	//_______________________________________________________
349f5eeb	47	AliTRDtrackingChamber::AliTRDtrackingChamber()
a8276d32	48	:TObject()
349f5eeb	49	,fDetector(-1)
b0a48c4d	50	,fX0(0.)
5eb768d6	51	// ,fExB(0.)
5eb768d6	52	// ,fVD(0.)
4eb02ab1	53	// ,fT0(0.)
5eb768d6	54	// ,fS2PRF(0.)
	55	// ,fDiffL(0.)
	56	// ,fDiffT(0.)
b0a48c4d	57	{}
	58
	59	//_______________________________________________________
	60	void AliTRDtrackingChamber::Clear(const Option_t *opt)
	61	{
fac58f00	62	for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++) fTB[itb].Clear(opt);
b0a48c4d	63	}
	64
	65	//_______________________________________________________
5eb768d6	66	Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *const geo, Bool_t hlt)
b0a48c4d	67	{
	68	// Init chamber and all time bins (AliTRDchamberTimeBin)
	69	// Calculates radial position of the chamber based on
	70	// radial positions of the time bins (calibration/alignment aware)
	71	//
349f5eeb	72	if(fDetector < 0 \|\| fDetector >= AliTRDgeometry::kNdet){
	73	AliWarning(Form("Detector index not set correctly to %d", fDetector));
	74	return kFALSE;
	75	}
	76
c79857d5	77	Int_t stack = AliTRDgeometry::GetStack(fDetector);
c79857d5	78	Int_t layer = AliTRDgeometry::GetLayer(fDetector);
b0a48c4d	79	AliTRDpadPlane *pp = geo->GetPadPlane(layer, stack);
	80	Double_t zl = pp->GetRow0ROC() - pp->GetRowEndROC();
	81	Double_t z0 = geo->GetRow0(layer, stack, 0) - zl;
	82	Int_t nrows = pp->GetNrows();
	83
	84	Int_t index[50], jtb = 0;
fac58f00	85	for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){
b0a48c4d	86	if(!fTB[itb]) continue;
	87	fTB[itb].SetRange(z0, zl);
	88	fTB[itb].SetNRows(nrows);
126991d9	89	fTB[itb].SetPlane(layer);
	90	fTB[itb].SetStack(stack);
	91	fTB[itb].SetSector(AliTRDgeometry::GetSector(fDetector));
b0a48c4d	92	fTB[itb].BuildIndices();
	93	index[jtb++] = itb;
	94	}
	95	if(jtb<2) return kFALSE;
5eb768d6	96
5eb768d6	97	AliTRDcalibDB *calib = AliTRDcalibDB::Instance();
4eb02ab1	98	Float_t t0;
5eb768d6	99	if(!hlt){
4eb02ab1	100	t0 = calib->GetT0Average(fDetector);
5eb768d6	101	}else{
4eb02ab1	102	t0 = calib->GetT0Det()->GetValue(fDetector);
5eb768d6	103	}
	104	// fVD = calib->GetVdriftAverage(fDetector);
	105	// fS2PRF = calib->GetPRFROC(fDetector)->GetMean(); fS2PRF *= fS2PRF;
	106	// fExB = AliTRDCommonParam::Instance()->GetOmegaTau(fVD);
	107	// AliTRDCommonParam::Instance()->GetDiffCoeff(fDiffL, fDiffT, fVD);
	108
b0a48c4d	109	// ESTIMATE POSITION OF PAD PLANE FOR THIS CHAMBER
dc9c471c	110	//fTB[Int_t(t0)].SetT0();
b0a48c4d	111	Double_t x0 = fTB[index[0]].GetX();
	112	Double_t x1 = fTB[index[1]].GetX();
	113	Double_t dx = (x0 - x1)/(index[1] - index[0]);
b0a48c4d	114	fX0 = x0 + dx*(index[0] - t0);
	115	return kTRUE;
	116	}
c79857d5	117
b0a48c4d	118	//_______________________________________________________
	119	Int_t AliTRDtrackingChamber::GetNClusters() const
	120	{
ac1dec3b	121	// Basic loop method
b0a48c4d	122	// Returns number of clusters in chamber
	123	//
	124	Int_t n = 0;
fac58f00	125	for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){
b0a48c4d	126	n += Int_t(fTB[itb]);
	127	}
	128	return n;
	129	}
	130
ac1dec3b	131	//_______________________________________________________
	132	void AliTRDtrackingChamber::Bootstrap(const AliTRDReconstructor *rec)
	133	{
	134	// Basic loop method
	135	// Bootstrap each time bin
	136	//
	137	AliTRDchamberTimeBin *jtb = &fTB[0];
fac58f00	138	for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){
ac1dec3b	139	(*jtb).Bootstrap(rec, fDetector);
	140	}
	141	}
	142
	143	//_______________________________________________________
	144	void AliTRDtrackingChamber::SetOwner()
	145	{
	146	// Basic loop method
	147	// Set ownership in time bins
	148	//
	149	AliTRDchamberTimeBin *jtb = &fTB[0];
fac58f00	150	for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){
ac1dec3b	151	if(!(Int_t(*jtb))) continue;
	152	(*jtb).SetOwner();
	153	}
	154	}
	155
b0a48c4d	156	//_______________________________________________________
	157	Double_t AliTRDtrackingChamber::GetQuality()
	158	{
	159	//
	160	// Calculate chamber quality for seeding.
	161	//
	162	//
	163	// Parameters :
	164	// layers : Array of propagation layers for this plane.
	165	//
	166	// Output :
	167	// plane quality factor for seeding
	168	//
	169	// Detailed description
	170	//
	171	// The quality of the plane for seeding is higher if:
	172	// 1. the average timebin population is closer to an integer number
	173	// 2. the distribution of clusters/timebin is closer to a uniform distribution.
	174	// - the slope of the first derivative of a parabolic fit is small or
	175	// - the slope of a linear fit is small
	176	//
	177
	178	Int_t ncl = 0;
	179	Int_t nused = 0;
	180	Int_t nClLayer;
fac58f00	181	for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
b0a48c4d	182	if(!(nClLayer = fTB[itb].GetNClusters())) continue;
	183	ncl += nClLayer;
	184	for(Int_t incl = 0; incl < nClLayer; incl++){
	185	if((fTB[itb].GetCluster(incl))->IsUsed()) nused++;
	186	}
	187	}
	188
	189	// calculate the deviation of the mean number of clusters from the
	190	// closest integer values
	191	Float_t nclMed = float(ncl-nused)/AliTRDtrackerV1::GetNTimeBins();
	192	Int_t ncli = Int_t(nclMed);
	193	Float_t nclDev = TMath::Abs(nclMed - TMath::Max(ncli, 1));
	194	nclDev -= (nclDev>.5) && ncli ? 1. : 0.;
	195	return TMath::Exp(-5.*TMath::Abs(nclDev));
	196
	197	// // get slope of the derivative
	198	// if(!fitter.Eval()) return quality;
	199	// fitter.PrintResults(3);
	200	// Double_t a = fitter.GetParameter(1);
	201	//
	202	// printf("ncl_dev(%f) a(%f)\n", ncl_dev, a);
	203	// return quality*TMath::Exp(-a);
	204
	205	}
	206
	207
	208	//_______________________________________________________
4d6aee34	209	Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin &fakeLayer, AliTRDgeometry const geo, const AliTRDReconstructor *rec)
b0a48c4d	210	{
	211	//
	212	// Creates a seeding layer
	213	//
	214
	215	// constants
	216	const Int_t kMaxRows = 16;
	217	const Int_t kMaxCols = 144;
	218	const Int_t kMaxPads = 2304;
	219	Int_t timeBinMin = rec->GetRecoParam()->GetNumberOfPresamples();
	220	Int_t timeBinMax = rec->GetRecoParam()->GetNumberOfPostsamples();
	221
	222	// Get the geometrical data of the chamber
	223	Int_t layer = geo->GetLayer(fDetector);
	224	Int_t stack = geo->GetStack(fDetector);
	225	Int_t sector= geo->GetSector(fDetector);
	226	AliTRDpadPlane *pp = geo->GetPadPlane(layer, stack);
	227	Int_t nCols = pp->GetNcols();
	228	Float_t ymin = TMath::Min(pp->GetCol0(), pp->GetColEnd());
	229	Float_t ymax = TMath::Max(pp->GetCol0(), pp->GetColEnd());
	230	Float_t zmin = TMath::Min(pp->GetRow0(), pp->GetRowEnd());
	231	Float_t zmax = TMath::Max(pp->GetRow0(), pp->GetRowEnd());
	232	Float_t z0 = -1., zl = -1.;
	233	Int_t nRows = pp->GetNrows();
	234	Float_t binlength = (ymax - ymin)/nCols;
	235	//AliInfo(Form("ymin(%f) ymax(%f) zmin(%f) zmax(%f) nRows(%d) binlength(%f)", ymin, ymax, zmin, zmax, nRows, binlength));
	236
	237	// Fill the histogram
	238	Int_t nClusters;
	239	Int_t *histogram[kMaxRows]; // 2D-Histogram
	240	Int_t hvals[kMaxPads + 1]; memset(hvals, 0, sizeof(Int_t)*kMaxPads); // one entry in addition for termination flag
	241	Float_t *sigmas[kMaxRows];
	242	Float_t svals[kMaxPads]; memset(svals, 0, sizeof(Float_t)*kMaxPads);
4d6aee34	243	AliTRDcluster *c = NULL;
b0a48c4d	244	for(Int_t irs = 0; irs < kMaxRows; irs++){
	245	histogram[irs] = &hvals[irs*kMaxCols];
	246	sigmas[irs] = &svals[irs*kMaxCols];
	247	}
fac58f00	248	for(Int_t iTime = timeBinMin; iTime < AliTRDseedV1::kNtb-timeBinMax; iTime++){
b0a48c4d	249	if(!(nClusters = fTB[iTime].GetNClusters())) continue;
	250	z0 = fTB[iTime].GetZ0();
	251	zl = fTB[iTime].GetDZ0();
	252	for(Int_t incl = 0; incl < nClusters; incl++){
	253	c = fTB[iTime].GetCluster(incl);
	254	histogram[c->GetPadRow()][c->GetPadCol()]++;
	255	sigmas[c->GetPadRow()][c->GetPadCol()] += c->GetSigmaZ2();
	256	}
	257	}
	258
	259	// Now I have everything in the histogram, do the selection
	260	//Int_t nPads = nCols * nRows;
	261	// This is what we are interested in: The center of gravity of the best candidates
	262	Float_t cogyvals[kMaxPads]; memset(cogyvals, 0, sizeof(Float_t)*kMaxPads);
	263	Float_t cogzvals[kMaxPads]; memset(cogzvals, 0, sizeof(Float_t)*kMaxPads);
	264	Float_t *cogy[kMaxRows];
	265	Float_t *cogz[kMaxRows];
	266
	267	// Lookup-Table storing coordinates according to the bins
41f024fb	268	Float_t yLengths[kMaxCols]; memset(yLengths, 0, kMaxCols*sizeof(Float_t));
41f024fb	269	Float_t zLengths[kMaxRows]; memset(zLengths, 0, kMaxRows*sizeof(Float_t));
b0a48c4d	270	for(Int_t icnt = 0; icnt < nCols; icnt++){
	271	yLengths[icnt] = pp->GetColPos(nCols - 1 - icnt) + binlength/2;
	272	}
	273	for(Int_t icnt = 0; icnt < nRows; icnt++){
	274	zLengths[icnt] = pp->GetRowPos(icnt) - pp->GetRowSize(icnt)/2;
	275	}
	276
	277	// A bitfield is used to mask the pads as usable
	278	Short_t mask[kMaxCols]; memset(mask, 0 ,sizeof(Short_t) * kMaxCols);//bool mvals[kMaxPads];
	279	for(UChar_t icount = 0; icount < nRows; icount++){
	280	cogy[icount] = &cogyvals[icount*kMaxCols];
	281	cogz[icount] = &cogzvals[icount*kMaxCols];
	282	}
	283	// In this array the array position of the best candidates will be stored
	284	Int_t cand[AliTRDtrackerV1::kMaxTracksStack];
	285	Float_t sigcands[AliTRDtrackerV1::kMaxTracksStack];
	286
	287	// helper variables
	288	Int_t indices[kMaxPads]; memset(indices, -1, sizeof(Int_t)*kMaxPads);
	289	Int_t nCandidates = 0;
	290	Float_t norm, cogv;
	291	// histogram filled -> Select best bins
	292	Int_t nPads = nCols * nRows;
	293	// take out all the bins which have less than 3 entries (faster sorting)
	294	Int_t content[kMaxPads], dictionary[kMaxPads], nCont = 0, padnumber = 0;
	295	Int_t iter = &hvals[0], citer = &content[0], *diter = &dictionary[0]; // iterators for preselection
	296	const Int_t threshold = 2;
	297	hvals[nPads] = -1; // termination for iterator
	298	do{
	299	if(*iter > threshold){
	300	(citer++) = iter;
	301	*(diter++) = padnumber;
	302	nCont++;
	303	}
	304	padnumber++;
	305	}while(*(++iter) != -1);
	306	TMath::Sort(nCont, content, indices);
	307
	308	Int_t col, row, lower, lower1, upper, upper1;
	309	for(Int_t ib = 0; ib < nCont; ib++){
	310	if(nCandidates >= AliTRDtrackerV1::kMaxTracksStack){
0e0d327b	311	AliDebug(1, Form("Number of seed candidates %d exceeded maximum allowed per stack %d", nCandidates, AliTRDtrackerV1::kMaxTracksStack));
b0a48c4d	312	break;
	313	}
	314	// Positions
	315	row = dictionary[indices[ib]]/nCols;
	316	col = dictionary[indices[ib]]%nCols;
	317	// here will be the threshold condition:
	318	if((mask[col] & (1 << row)) != 0) continue; // Pad is masked: continue
	319	// if(histogram[row][col] < TMath::Max(threshold, 1)){ // of course at least one cluster is needed
	320	// break; // number of clusters below threshold: break;
	321	// }
	322	// passing: Mark the neighbors
	323	lower = TMath::Max(col - 1, 0); upper = TMath::Min(col + 2, nCols);
	324	lower1 = TMath::Max(row - 1, 0); upper1 = TMath::Min(row + 2, nCols);
	325	for(Int_t ic = lower; ic < upper; ++ic)
	326	for(Int_t ir = lower1; ir < upper1; ++ir){
	327	if(ic == col && ir == row) continue;
	328	mask[ic] \|= (1 << ir);
	329	}
	330	// Storing the position in an array
	331	// testing for neigboring
	332	cogv = 0;
	333	norm = 0;
	334	lower = TMath::Max(col - 1, 0);
	335	upper = TMath::Min(col + 2, nCols);
	336	for(Int_t inb = lower; inb < upper; ++inb){
	337	cogv += yLengths[inb] * histogram[row][inb];
	338	norm += histogram[row][inb];
	339	}
	340	cogy[row][col] = cogv / norm;
	341	cogv = 0; norm = 0;
	342	lower = TMath::Max(row - 1, 0);
	343	upper = TMath::Min(row + 2, nRows);
	344	for(Int_t inb = lower; inb < upper; ++inb){
	345	cogv += zLengths[inb] * histogram[inb][col];
	346	norm += histogram[inb][col];
	347	}
	348	cogz[row][col] = Float_t(cogv) / norm;
	349	// passed the filter
	350	cand[nCandidates] = row*nCols + col; // store the position of a passig candidate into an Array
	351	sigcands[nCandidates] = sigmas[row][col] / histogram[row][col]; // never be a floating point exeption
	352	// Analysis output
	353	nCandidates++;
	354	}
	355	if(!nCandidates) return kFALSE;
	356
	357	Float_t pos[3], sig[2];
	358	Short_t signal[7]; memset(&signal[0], 0, 7*sizeof(Short_t));
	359
	360	new(fakeLayer) AliTRDchamberTimeBin(layer, stack, sector, z0, zl);
	361	fakeLayer->SetReconstructor(rec);
ac1dec3b	362	fakeLayer->SetNRows(nRows);
ac1dec3b	363	fakeLayer->SetOwner(kFALSE);
b0a48c4d	364	if(nCandidates){
	365	UInt_t fakeIndex = 0;
	366	for(Int_t ican = 0; ican < nCandidates; ican++){
	367	row = cand[ican] / nCols;
	368	col = cand[ican] % nCols;
	369	//temporary
	370	Int_t n = 0; Double_t x = 0., y = 0., z = 0.;
fac58f00	371	for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
b0a48c4d	372	if(!(nClusters = fTB[itb].GetNClusters())) continue;
	373	for(Int_t incl = 0; incl < nClusters; incl++){
	374	c = fTB[itb].GetCluster(incl);
	375	if(c->GetPadRow() != row) continue;
	376	if(TMath::Abs(c->GetPadCol() - col) > 2) continue;
	377	x += c->GetX();
	378	y += c->GetY();
	379	z += c->GetZ();
	380	n++;
	381	}
	382	}
21606e2c	383	if(!n) continue;
b0a48c4d	384	pos[0] = x/n;
	385	pos[1] = y/n;
	386	pos[2] = z/n;
	387	sig[0] = .02;
	388	sig[1] = sigcands[ican];
4d6aee34	389	fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
b0a48c4d	390	}
b0a48c4d	391	}
b0a48c4d	392	fakeLayer->BuildIndices();
ac1dec3b	393	//fakeLayer->Print();
b0a48c4d	394
a2fbb6ec	395	if(rec->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 3){
b0a48c4d	396	//TMatrixD hist(nRows, nCols);
	397	//for(Int_t i = 0; i < nRows; i++)
	398	// for(Int_t j = 0; j < nCols; j++)
	399	// hist(i,j) = histogram[i][j];
a2fbb6ec	400	TTreeSRedirector &cstreamer = *rec->GetDebugStream(AliTRDrecoParam::kTracker);
b0a48c4d	401	cstreamer << "GetSeedingLayer"
	402	<< "layer=" << layer
	403	<< "ymin=" << ymin
	404	<< "ymax=" << ymax
	405	<< "zmin=" << zmin
	406	<< "zmax=" << zmax
	407	<< "L.=" << fakeLayer
	408	//<< "Histogram.=" << &hist
	409	<< "\n";
	410	}
	411
	412	return kTRUE;
	413	}
	414
6c207d50	415
	416	//_______________________________________________________
	417	void AliTRDtrackingChamber::Print(Option_t *opt) const
	418	{
4d6aee34	419	// Print the chamber status
6c207d50	420	if(!GetNClusters()) return;
	421	AliInfo(Form("fDetector = %d", fDetector));
	422	AliInfo(Form("fX0 = %7.3f", fX0));
	423	const AliTRDchamberTimeBin *itb = &fTB[0];
fac58f00	424	for(Int_t jtb=0; jtb<AliTRDseedV1::kNtb; jtb++, itb++) (*itb).Print(opt);
6c207d50	425	}
fac58f00	426
	427
	428	//_______________________________________________________
	429	void AliTRDtrackingChamber::Update()
	430	{
	431	// Steer purging of used and shared clusters
	432
	433	AliTRDchamberTimeBin *jtb = &fTB[0];
	434	for(Int_t itb=AliTRDseedV1::kNtb; itb--; ++jtb){
	435	if(!(Int_t(*jtb))) continue;
	436	(*jtb).BuildIndices();
	437	}
	438	}
	439