ROOT logo
/**************************************************************************
* 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: AliTRDchamberTimeBin.cxx 23313 2008-01-11 14:56:43Z cblume $ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Organization of clusters at the level of 1 TRD chamber.                  //
//  The data structure is used for tracking at the stack level.              //
//                                                                           //
//  Functionalities:                                                         //
//   1. cluster organization and sorting                                     //
//   2. fast data navigation                                                 //
//                                                                           //
//  Authors:                                                                 //
//    Alex Bercuci <A.Bercuci@gsi.de>                                        //
//    Markus Fasel <M.Fasel@gsi.de>                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <TObject.h>
#include <TMath.h>
#include <TTreeStream.h>

#include "AliLog.h"
#include "AliTRDcluster.h"
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDchamberTimeBin.h"
#include "AliTRDrecoParam.h"
#include "AliTRDReconstructor.h"

ClassImp(AliTRDchamberTimeBin)

//_____________________________________________________________________________
AliTRDchamberTimeBin::AliTRDchamberTimeBin(Int_t plane, Int_t stack, Int_t sector, Double_t z0, Double_t zLength)
  :TObject()
  ,fkReconstructor(NULL)
  ,fPlane(plane)
  ,fStack(stack)
  ,fSector(sector)
  ,fNRows(kMaxRows)
  ,fN(0)
  ,fX(0.)
  ,fZ0(z0)
  ,fZLength(zLength)
{
  //
  // Default constructor (Only provided to use AliTRDchamberTimeBin with arrays)
  //
  SetBit(kT0, kFALSE);
  SetBit(kOwner, kFALSE);
  memset(fPositions, 1, kMaxRows*sizeof(UChar_t));
  memset(fClusters, 0, kMaxClustersLayer*sizeof(AliTRDcluster*));
  memset(fIndex, 1, kMaxClustersLayer*sizeof(UInt_t));
}


//_____________________________________________________________________________
AliTRDchamberTimeBin::AliTRDchamberTimeBin(const AliTRDchamberTimeBin &layer):
  TObject()
  ,fkReconstructor(layer.fkReconstructor)
  ,fPlane(layer.fPlane)
  ,fStack(layer.fStack)
  ,fSector(layer.fSector)
  ,fNRows(layer.fNRows)
  ,fN(layer.fN)
  ,fX(layer.fX)
  ,fZ0(layer.fZ0)
  ,fZLength(layer.fZLength)
{
// Copy Constructor 
  
  SetBit(kT0, layer.IsT0());
  SetBit(kOwner, kFALSE);
  for(int i=0; i<kMaxRows; i++) fPositions[i] = layer.fPositions[i];
  memcpy(&fClusters[0], &layer.fClusters[0], kMaxClustersLayer*sizeof(AliTRDcluster*));
  memcpy(&fIndex[0], &layer.fIndex[0], kMaxClustersLayer*sizeof(UInt_t));


// 	BuildIndices();
}

//_____________________________________________________________________________
AliTRDchamberTimeBin &AliTRDchamberTimeBin::operator=(const AliTRDchamberTimeBin &layer)
{
// Assignment operator

  if (this != &layer) layer.Copy(*this);
  return *this;
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::Clear(const Option_t *) 
{ 
  // Reset the Chamber Timebin
  if(IsOwner())
    for(Int_t it = 0; it<kMaxClustersLayer; it++)
      delete fClusters[it];
  memset(fClusters,0,kMaxClustersLayer*sizeof(fClusters[0]));
  fN = 0; 
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::Copy(TObject &o) const
{
// Copy method. Performs a deep copy of all data from this object to object o.
  
  AliTRDchamberTimeBin &layer = (AliTRDchamberTimeBin &)o;
  layer.fkReconstructor = fkReconstructor;
  layer.fPlane       = fPlane;
  layer.fStack       = fStack;
  layer.fSector      = fSector;
  layer.fNRows       = fNRows;
  layer.fN           = fN;
  layer.fX           = fX;
  layer.fZ0          = fZ0;
  layer.fZLength     = fZLength;
  layer.SetT0(IsT0());
  layer.SetBit(kOwner, kFALSE);
  
  for(int i=0; i<kMaxRows; i++) layer.fPositions[i] = fPositions[i];
  memcpy(&layer.fClusters[0], &fClusters[0], kMaxClustersLayer*sizeof(AliTRDcluster*));
  memcpy(&layer.fIndex[0], &fIndex[0], kMaxClustersLayer*sizeof(UInt_t));
  
  TObject::Copy(layer); // copies everything into layer
  
// 	layer.BuildIndices();
}

//_____________________________________________________________________________
AliTRDchamberTimeBin::~AliTRDchamberTimeBin()
{
// Destructor
  if(IsOwner()){ 
    for(AliTRDcluster **cit = &fClusters[0]; (*cit); cit++) delete (*cit);
  }
}

//_____________________________________________________________________________
void  AliTRDchamberTimeBin::SetOwner(Bool_t copy) 
{
// Sets the ownership of the clusters to this 
// If option "copy" is kTRUE [default] the clusters 
// are also copied otherwise only the ownership bit 
// is flipped.

  SetBit(kOwner, kTRUE);
  if(!copy) return;
  for(AliTRDcluster **cit = &fClusters[0]; (*cit); ++cit){
    (*cit) = new AliTRDcluster(*(*cit)); 
  }
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::SetRange(Float_t z0, Float_t zLength)
{
// Sets the range in z-direction
//
// Parameters:
//   z0      : starting position of layer in the z direction
//   zLength : length of layer in the z direction 

  fZ0 = (z0 <= z0 + zLength) ? z0 : z0 + zLength;
  fZLength = TMath::Abs(zLength);
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::InsertCluster(AliTRDcluster *c, UInt_t index) 
{
  //
  // Insert cluster in cluster array.
  // Clusters are sorted according to Y coordinate.  
  //

  //if (fTimeBinIndex < 0) { 
    //AliWarning("Attempt to insert cluster into non-sensitive time bin!\n");
    //return;
  //}

  if (fN == (Int_t) kMaxClustersLayer) {
    //AliWarning("Too many clusters !\n"); 
    return;
  }

  if (fN == 0) {
    fIndex[0]       = index; 
    fClusters[fN++] = c; 
    return;
  }

  Int_t i = Find(c->GetY());
  memmove(fClusters+i+1,fClusters+i,(fN-i)*sizeof(AliTRDcluster*));
  memmove(fIndex   +i+1,fIndex   +i,(fN-i)*sizeof(UInt_t)); 
  fIndex[i]    = index; 
  fClusters[i] = c; 
  fN++;
}

//___________________________________________________
void AliTRDchamberTimeBin::Bootstrap(const AliTRDReconstructor *rec, Int_t det)
{
// Reinitialize all data members from the clusters array
// It has to be used after reading from disk

  fkReconstructor = rec;
  fPlane  = AliTRDgeometry::GetLayer(det);
  fStack  = AliTRDgeometry::GetStack(det);
  fSector = AliTRDgeometry::GetSector(det);
  AliTRDgeometry g;
  fNRows  = g.GetPadPlane(fPlane, fStack)->GetNrows();
  fN = 0;
  for(AliTRDcluster **cit = &fClusters[0]; (*cit); cit++) fN++;
  BuildIndices();
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
{
// Rearrangement of the clusters belonging to the propagation layer for the stack.
//
// Detailed description
//
// The array indices of all clusters in one PropagationLayer are stored in
// array. The array is divided into several bins.
// The clusters are sorted in increasing order of their y coordinate.
//
// Sorting algorithm: TreeSearch
//

  if(!fN) return;

  // Select clusters that belong to the Stack
  Int_t nClStack = 0;					// Internal counter
  for(Int_t i = 0; i < fN; i++){
    if(fClusters[i]->IsUsed() || fClusters[i]->IsShared()){
      fClusters[i] = NULL;
      fIndex[i] = 0xffff;
    } else nClStack++;
  }
  if(nClStack > kMaxClustersLayer) AliInfo(Form("Number of clusters in stack %d exceed buffer size %d. Truncating.", nClStack, kMaxClustersLayer));
    
  // Nothing in this time bin. Reset indexes 
  if(!nClStack){
    fN = 0;
    memset(&fPositions[0], 0, sizeof(UChar_t) * kMaxRows);
    memset(&fClusters[0], 0, sizeof(AliTRDcluster*) * kMaxClustersLayer);
    memset(&fIndex[0], 0, sizeof(UInt_t) * kMaxClustersLayer);
    return;
  }
  
  // Make a copy
  AliTRDcluster *helpCL[kMaxClustersLayer];
  UInt_t helpInd[kMaxClustersLayer];
  nClStack = 0;
  // Defining iterators
  AliTRDcluster **fcliter = &fClusters[0], **hcliter = &helpCL[0]; UInt_t *finditer = &fIndex[0], *hinditer = &helpInd[0];
  AliTRDcluster *tmpcl = NULL;
  for(Int_t i = 0; i < TMath::Min(fN, kMaxClustersLayer); i++){
    if(!(tmpcl = *(fcliter++))){
    	finditer++;
    	continue;
    }
    *(hcliter++)  = tmpcl;
    *(hinditer++) = *finditer;
    tmpcl = NULL;
    *(finditer++) = 0xffff;
    nClStack++;
  }
  
  // do clusters arrangement
  fX = 0.;
  fN =  nClStack;
  nClStack = 0;
  // Reset Positions array
  memset(fPositions, 0, sizeof(UChar_t)*kMaxRows);
  AliTRDcluster **cliter = &helpCL[0]; // Declare iterator running over the whole array
  const AliTRDrecoParam* const recoParam = fkReconstructor->GetRecoParam(); //the dynamic cast in GetRecoParam is slow, so caching the pointer to it
  Int_t tb(-1);
  for(Int_t i = 0; i < fN; i++){
    // boundary check
    AliTRDcluster *cl = *(cliter++);
    UChar_t rowIndex = cl->GetPadRow();
    if(tb<0) tb=cl->GetLocalTimeBin();
    // Insert Leaf
    Int_t pos = FindYPosition(cl->GetY(), rowIndex, nClStack);
    if(pos == -2) continue;   // zbin error;
    else if(pos == -1) {    // zbin is empty;
      Int_t upper = (rowIndex == fNRows - 1) ? nClStack : fPositions[rowIndex + 1];
      memmove(fClusters + upper + 1, fClusters + upper, (sizeof(AliTRDcluster *))*(nClStack-upper));
      memmove(fIndex + upper + 1, fIndex + upper, (sizeof(UInt_t))*(nClStack-upper));
      fClusters[upper] = cl;
      fIndex[upper] = helpInd[i]; 
      // Move All pointer one position back
      for(UChar_t j = rowIndex + 1; j < fNRows; j++) fPositions[j]++;
      nClStack++;
    } else {		// zbin not empty
      memmove(fClusters + pos + 2, fClusters + pos+1, (sizeof(AliTRDcluster *))*(nClStack-(pos+1)));
      memmove(fIndex + pos + 2, fIndex + pos+1, (sizeof(UInt_t))*(nClStack-(pos+1)));
      fClusters[pos + 1] = cl;	//fIndex[i];
      fIndex[pos + 1] = helpInd[i];
      // Move All pointer one position back
      for(UChar_t j = rowIndex + 1; j < fNRows; j++) fPositions[j]++;	
      nClStack++;
    }

    // calculate mean x
    fX += cl->GetX(); 
    
    // Debug Streaming
    if(recoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 3){
      AliTRDcluster dcl(*cl);
      TTreeSRedirector &cstream = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
      cstream << "BuildIndices"
      << "Plane="    << fPlane
      << "Stack="    << fStack
      << "Sector="   << fSector
      << "Iter="     << iter
      << "C.="       << &dcl
      << "rowIndex=" << rowIndex
      << "\n";
    }
  }

// 	AliInfo("Positions");
// 	for(int ir=0; ir<fNRows; ir++) printf("pos[%d] %d\n", ir, fPositions[ir]);
  if(nClStack < fN){
    AliWarning(Form("Found %d out of %d clusters outside in ChamberTimeBin[%02d_%d_%d|%2d]", fN-nClStack, fN, fSector, fStack, fPlane, tb));
    fN =  nClStack;
    if(!fN){ // Nothing left in this time bin. Reset indexes
      memset(&fPositions[0], 0, sizeof(UChar_t) * kMaxRows);
      memset(&fClusters[0], 0, sizeof(AliTRDcluster*) * kMaxClustersLayer);
      memset(&fIndex[0], 0, sizeof(UInt_t) * kMaxClustersLayer);
      return;
    }
  }
  if(fN) fX /= fN;
}

//_____________________________________________________________________________
Int_t AliTRDchamberTimeBin::Find(Float_t y) const
{
  //
  // Returns index of the cluster nearest in Y    
  //

  if (fN <= 0) return 0;
  
  if (y <= fClusters[0]->GetY()) return 0;
  
  if (y >  fClusters[fN-1]->GetY()) return fN;
  

  Int_t b = 0;
  Int_t e = fN - 1;
  Int_t m = (b + e) / 2;

  for ( ; b < e; m = (b + e) / 2) {
    if (y > fClusters[m]->GetY()) b = m + 1;
    else e = m;
  }

  return m;
}    

//_____________________________________________________________________________
Int_t AliTRDchamberTimeBin::FindYPosition(Double_t y, UChar_t z, Int_t nClusters) const
{
//
// Tree search Algorithm to find the nearest left cluster for a given
// y-position in a certain z-bin (in fact AVL-tree). 
// Making use of the fact that clusters are sorted in y-direction.
//
// Parameters:
//   y : y position of the reference point in tracking coordinates
//   z : z reference bin.
//   nClusters : 
//
// Output :
// Index of the nearest left cluster in the StackLayer indexing (-1 if no clusters are found)
//

  if(z>=fNRows){ // check pad row of cluster
    AliDebug(1, Form("Row[%2d] outside range [0 %2d] in %02d_%d_%d.", z, fNRows, fSector, fStack, fPlane));
    return -2;
  }
  Int_t start = fPositions[z]; 		// starting Position of the bin
  Int_t upper = (Int_t)((z != fNRows - 1) ? fPositions[z+1] : nClusters); // ending Position of the bin 
  Int_t end = upper - 1; // ending Position of the bin 
  if(end < start) return -1; // Bin is empty
  Int_t middle = static_cast<Int_t>((start + end)/2);
  // 1st Part: climb down the tree: get the next cluster BEFORE ypos
  while(start + 1 < end){
    if(y >= fClusters[middle]->GetY()) start = middle;
    else end = middle;
    middle = static_cast<Int_t>((start + end)/2);
  }
  if(y > fClusters[end]->GetY()) return end;
  return start;
}

//_____________________________________________________________________________
Int_t AliTRDchamberTimeBin::FindNearestYCluster(Double_t y, UChar_t z) const
{
//
// Tree search Algorithm to find the nearest cluster for a given
// y-position in a certain z-bin (in fact AVL-tree). 
// Making use of the fact that clusters are sorted in y-direction.
//
// Parameters:
//   y : y position of the reference point in tracking coordinates
//   z : z reference bin.
//
// Output 
// Index of the nearest cluster in the StackLayer indexing (-1 if no clusters are found)
//

  Int_t position = FindYPosition(y, z, fN);
  if(position == -2 || position == -1) return position; // bin empty
  // FindYPosition always returns the left Neighbor. We don't know if the left or the right Neighbor is nearest
  // to the Reference y-position, so test both
  Int_t upper = (Int_t)((z < fNRows-1) ? fPositions[z+1] : fN); // ending Position of the bin
  if((position + 1) < (upper)){
    if(TMath::Abs(y - fClusters[position + 1]->GetY()) < TMath::Abs(y - fClusters[position]->GetY())) return position + 1;
    else return position;
  }
  return position;
}

//_____________________________________________________________________________
Int_t AliTRDchamberTimeBin::SearchNearestCluster(Double_t y, Double_t z, Double_t maxroady, Double_t maxroadz) const
{
//
// Finds the nearest cluster from a given point in a defined range.
// Distance is determined in a 2D space by the 2-Norm.
//
// Parameters :
//   y : y position of the reference point in tracking coordinates
//   z : z reference bin.
//   maxroady : maximum searching distance in y direction
//   maxroadz : maximum searching distance in z direction
//
// Output 
// Index of the nearest cluster in the StackLayer indexing (-1 if no cluster is found).
// Cluster can be accessed with the operator[] or GetCluster(Int_t index)
//
// Detail description
//
// The following steps are perfomed:
// 1. Get the expected z bins inside maxroadz.
// 2. For each z bin find nearest y cluster.
// 3. Select best candidate
//
  Int_t   index   = -1;
  // initial minimal distance will be represented as ellipse: semi-major = z-direction
  // later 2-Norm will be used  
// 	Float_t nExcentricity = TMath::Sqrt(maxroadz*maxroadz - maxroad*maxroad)/maxroadz;
  Float_t mindist = maxroadz;
  
  // not very nice but unfortunately neccessarry: we have ho check the neighbors in both directions (+ and -) too. How 
  // much neighbors depends on the Quotient maxroadz/fZLength   
  UChar_t maxRows = 3;
  UChar_t zpos[kMaxRows];
  // Float_t mindist = TMath::Sqrt(maxroad*maxroad + maxroadz*maxroadz);
// 	UChar_t myZbin = FindTreePosition(z, fZ0 + fZLength/2, fZLength/4, 8, 8, kFALSE);
  UChar_t myZbin = fNRows - 1 - (UChar_t)(TMath::Abs(fZ0 - z)/fZLength * fNRows);
  if(z < fZ0) myZbin = fNRows - 1;
  if(z > fZ0 + fZLength) myZbin = 0;
  //printf("\n%f < %f < %f [%d]\n", fZ0, z, fZ0 + fZLength, myZbin);
  //for(int ic=0; ic<fN; ic++) printf("%d z = %f row %d\n", ic, fClusters[ic]->GetZ(), fClusters[ic]->GetPadRow());

  UChar_t nNeighbors = 0;
  for(UChar_t i = 0; i < maxRows; i++){
    if((myZbin - 1 + i) < 0) continue;
    if((myZbin - 1 + i) > fNRows - 1) break;
    zpos[nNeighbors] = myZbin - 1 + i;
    nNeighbors++;
  }
  Float_t ycl = 0, zcl = 0;
  for(UChar_t neighbor = 0; neighbor < nNeighbors; neighbor++){	// Always test the neighbors too
    Int_t pos = FindNearestYCluster(y, zpos[neighbor]);
    if(pos == -1) continue;	// No cluster in bin
    AliTRDcluster *c = (AliTRDcluster *) (fClusters[pos]);
    if(c->IsUsed()) continue;		// we are only interested in unused clusters
    ycl = c->GetY();
    // Too far away in y-direction (Prearrangement)
    if (TMath::Abs(ycl - y) > maxroady){ 
      //printf("y[%f] ycl[%f] roady[%f]\n", y, ycl, maxroady);
      continue;
    }
    zcl = c->GetZ();
    // Too far away in z-Direction
    // (Prearrangement since we have not so many bins to test)
    if (TMath::Abs(zcl - z) > maxroadz) continue;
    
    Float_t dist;		// distance defined as 2-Norm	
    // if we havent found a Particle that is in the ellipse around (y,z) with maxroad as semi-minor and
    // maxroadz as semi-major, we take the radius of the ellipse concerning the cluster as mindist, later we 
    // take the 2-Norm when we found a cluster inside the ellipse (The value 10000 is taken because it is surely
    // large enough to be usable as an indicator whether we have found a nearer cluster or not)
// 		if(mindist > 10000.){
// 			Float_t phi = ((zcl - z) == 0) ? TMath::Pi()/2 : TMath::ATan((ycl - y)/(zcl - z));
// 			mindist = maxroad/TMath::Sqrt(1 - nExcentricity*nExcentricity * (TMath::Cos(phi))*(TMath::Cos(phi)));
// 		}
    dist = TMath::Max(TMath::Abs(y-ycl),TMath::Abs(z-zcl));	// infinity Norm
// 		dist = TMath::Sqrt((ycl - y)*(ycl - y) + (zcl - z)*(zcl - z));
    if((Int_t)(dist * 100000) < (Int_t)(mindist * 100000)){
    //if((dist = TMath::Sqrt((ycl - y)*(ycl - y) + (zcl - z)*(zcl - z))) < mindist){
      mindist = dist;
      index   = pos;
    }	
  }
  // This is the Array Position in fIndex2D of the Nearest cluster: if a
  // cluster is called, then the function has to retrieve the Information
  // which is Stored in the Array called, the function
  return index;
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::BuildCond(AliTRDcluster * const cl, Double_t *cond, UChar_t Layer, Double_t theta, Double_t phi)
{
// Helper function to calculate the area where to expect a cluster in THIS
// layer. 
//
// Parameters :
//   cl    : 
//   cond  :
//   Layer : 
//   theta : 
//   phi   : 
//
// Detail description
//
// Helper function to calculate the area where to expect a cluster in THIS
// layer. by using the information of a former cluster in another layer
// and the angle in theta- and phi-direction between layer 0 and layer 3.
// If the layer is zero, initial conditions are calculated. Otherwise a
// linear interpolation is performed. 
//Begin_Html
//<img src="gif/build_cond.gif">
//End_Html
//

  if(!fkReconstructor){
    AliError("Reconstructor not set.");
    return;
  }
  
  if(Layer == 0){
    cond[0] = cl->GetY();			// center: y-Direction
    cond[1] = cl->GetZ();			// center: z-Direction
    cond[2] = fkReconstructor->GetRecoParam()->GetMaxPhi()   * (cl->GetX() - GetX()) + 1.0;			// deviation: y-Direction
    cond[3] = fkReconstructor->GetRecoParam()->GetMaxTheta() * (cl->GetX() - GetX()) + 1.0;			// deviation: z-Direction
  } else {
    cond[0] = cl->GetY() + phi   * (GetX() - cl->GetX()); 
    cond[1] = cl->GetZ() + theta * (GetX() - cl->GetX());
    cond[2] = fkReconstructor->GetRecoParam()->GetRoad0y() + phi;
    cond[3] = fkReconstructor->GetRecoParam()->GetRoad0z();
  }
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::GetClusters(const Double_t * const cond, Int_t *index, Int_t& ncl, Int_t BufferSize)
{
// Finds all clusters situated in this layer inside a rectangle  given by the center an ranges.
//
// Parameters :
//   cond  :
//   index : 
//   ncl :
//   BufferSize   :
//
// Output :
//
// Detail description
//
// Function returs an array containing the indices in the stacklayer of
// the clusters found an  the number of found clusters in the stacklayer

  ncl = 0;
  memset(index, 0, BufferSize*sizeof(Int_t));
  if(fN == 0) return;
    
  //Boundary checks
  Double_t zvals[2];
  if(((cond[1] - cond[3]) >= (fZ0 + fZLength)) || (cond[1] + cond[3]) <= fZ0) return; // We are outside of the chamvber
  zvals[0] = ((cond[1] - cond[3]) < fZ0) ? fZ0 : (cond[1] - cond[3]);
  zvals[1] = ((cond[1] + cond[3]) < fZ0 + fZLength) ? (cond[1] + cond[3]) : fZ0 + fZLength - 1.E-3;

  UChar_t zhi = fNRows - 1 - (UChar_t)(TMath::Abs(fZ0 - zvals[0])/fZLength * fNRows);
  UChar_t zlo = fNRows - 1 - (UChar_t)(TMath::Abs(fZ0 - zvals[1])/fZLength * fNRows);

/*	AliInfo(Form("yc[%f] zc[%f] dy[%f] dz[%f]", cond[0], cond[1], cond[2], cond[3]));
  PrintClusters();
  AliInfo(Form("zlo[%f] zhi[%f]", zvals[0], zvals[1]));
  AliInfo(Form("zlo[%d] zhi[%d]", zlo, zhi));*/

  Double_t ylo = cond[0] - cond[2],
           yhi = cond[0] + cond[2];
  //printf("CTB : ylo[%f] yhi[%f]\n", ylo, yhi);
  //Preordering in Direction z saves a lot of loops (boundary checked)
  for(UChar_t z = zlo; z <= zhi; z++){
    UInt_t upper = (z < fNRows-1) ? fPositions[z+1] : fN;
    //AliInfo(Form("z[%d] y [%d %d]", z, fPositions[z], upper));
    for(Int_t y = fPositions[z]; y < (Int_t)upper; y++){
      if(ncl == BufferSize){
        AliDebug(1, Form("Buffer size [%d] riched. Some clusters may be lost.", BufferSize));
        return;	//Buffer filled
      }
      
      if(fClusters[y]->GetY() > yhi) break;			// Abbortion conditions!!!
      if(fClusters[y]->GetY() < ylo) continue;	// Too small
      if(((Int_t)((fClusters[y]->GetZ())*1000) < (Int_t)(zvals[0]*1000)) || ((Int_t)((fClusters[y]->GetZ())*1000) > (Int_t)(zvals[1]*1000))){/*printf("exit z\n"); TODO*/ continue;}
      index[ncl] = y;
      ncl++;
    }
  }
  if(ncl>fN) AliError(Form("Clusters found %d > %d (clusters in layer)", ncl, fN));
}

//_____________________________________________________________________________
AliTRDcluster *AliTRDchamberTimeBin::GetNearestCluster(Double_t *cond)
{
// Function returning a pointer to the nearest cluster (nullpointer if not successfull).
//
// Parameters :
//   cond  :
//
// Output :
//   pointer to the nearest cluster (nullpointer if not successfull).
// 
// Detail description
//
// returns a pointer to the nearest cluster (nullpointer if not
// successfull) by the help of the method FindNearestCluster
  
  
  Double_t maxroad  = fkReconstructor->GetRecoParam()->GetRoad2y();
  Double_t maxroadz = fkReconstructor->GetRecoParam()->GetRoad2z();
  
  Int_t index = SearchNearestCluster(cond[0],cond[1],maxroad,maxroadz);
  AliTRDcluster *returnCluster = NULL;
  if(index != -1) returnCluster = (AliTRDcluster *) fClusters[index];
  return returnCluster;
}

//_____________________________________________________________________________
void AliTRDchamberTimeBin::Print(Option_t *) const
{
// Prints the position of each cluster in the stacklayer on the stdout
//
  if(!fN) return;
  AliInfo(Form("Layer[%d] Stack[%d] Sector[%2d] nRows[%2d]", fPlane, fStack, fSector, fNRows));
  AliInfo(Form("Z0[%7.3f] Z1[%7.3f]", fZ0, fZ0+fZLength));
  AliTRDcluster* const* icl = &fClusters[0];
  for(Int_t jcl = 0; jcl < fN; jcl++, icl++){
    AliInfo(Form("%2d X[%7.3f] Y[%7.3f] Z[%7.3f] tb[%2d] col[%3d] row[%2d] used[%s]", jcl,  (*icl)->GetX(), (*icl)->GetY(), (*icl)->GetZ(), (*icl)->GetLocalTimeBin(), (*icl)->GetPadCol(), (*icl)->GetPadRow(),
    (*icl)->IsUsed() ? "y" : "n"));
  }
  Int_t irow = 0;
  for(UChar_t const* pos = &fPositions[0]; irow<fNRows; pos++, irow++){ 
    if((*pos) != 0xff) AliInfo(Form("r[%2d] pos[%d]", irow, (*pos)));
  }
}
 AliTRDchamberTimeBin.cxx:1
 AliTRDchamberTimeBin.cxx:2
 AliTRDchamberTimeBin.cxx:3
 AliTRDchamberTimeBin.cxx:4
 AliTRDchamberTimeBin.cxx:5
 AliTRDchamberTimeBin.cxx:6
 AliTRDchamberTimeBin.cxx:7
 AliTRDchamberTimeBin.cxx:8
 AliTRDchamberTimeBin.cxx:9
 AliTRDchamberTimeBin.cxx:10
 AliTRDchamberTimeBin.cxx:11
 AliTRDchamberTimeBin.cxx:12
 AliTRDchamberTimeBin.cxx:13
 AliTRDchamberTimeBin.cxx:14
 AliTRDchamberTimeBin.cxx:15
 AliTRDchamberTimeBin.cxx:16
 AliTRDchamberTimeBin.cxx:17
 AliTRDchamberTimeBin.cxx:18
 AliTRDchamberTimeBin.cxx:19
 AliTRDchamberTimeBin.cxx:20
 AliTRDchamberTimeBin.cxx:21
 AliTRDchamberTimeBin.cxx:22
 AliTRDchamberTimeBin.cxx:23
 AliTRDchamberTimeBin.cxx:24
 AliTRDchamberTimeBin.cxx:25
 AliTRDchamberTimeBin.cxx:26
 AliTRDchamberTimeBin.cxx:27
 AliTRDchamberTimeBin.cxx:28
 AliTRDchamberTimeBin.cxx:29
 AliTRDchamberTimeBin.cxx:30
 AliTRDchamberTimeBin.cxx:31
 AliTRDchamberTimeBin.cxx:32
 AliTRDchamberTimeBin.cxx:33
 AliTRDchamberTimeBin.cxx:34
 AliTRDchamberTimeBin.cxx:35
 AliTRDchamberTimeBin.cxx:36
 AliTRDchamberTimeBin.cxx:37
 AliTRDchamberTimeBin.cxx:38
 AliTRDchamberTimeBin.cxx:39
 AliTRDchamberTimeBin.cxx:40
 AliTRDchamberTimeBin.cxx:41
 AliTRDchamberTimeBin.cxx:42
 AliTRDchamberTimeBin.cxx:43
 AliTRDchamberTimeBin.cxx:44
 AliTRDchamberTimeBin.cxx:45
 AliTRDchamberTimeBin.cxx:46
 AliTRDchamberTimeBin.cxx:47
 AliTRDchamberTimeBin.cxx:48
 AliTRDchamberTimeBin.cxx:49
 AliTRDchamberTimeBin.cxx:50
 AliTRDchamberTimeBin.cxx:51
 AliTRDchamberTimeBin.cxx:52
 AliTRDchamberTimeBin.cxx:53
 AliTRDchamberTimeBin.cxx:54
 AliTRDchamberTimeBin.cxx:55
 AliTRDchamberTimeBin.cxx:56
 AliTRDchamberTimeBin.cxx:57
 AliTRDchamberTimeBin.cxx:58
 AliTRDchamberTimeBin.cxx:59
 AliTRDchamberTimeBin.cxx:60
 AliTRDchamberTimeBin.cxx:61
 AliTRDchamberTimeBin.cxx:62
 AliTRDchamberTimeBin.cxx:63
 AliTRDchamberTimeBin.cxx:64
 AliTRDchamberTimeBin.cxx:65
 AliTRDchamberTimeBin.cxx:66
 AliTRDchamberTimeBin.cxx:67
 AliTRDchamberTimeBin.cxx:68
 AliTRDchamberTimeBin.cxx:69
 AliTRDchamberTimeBin.cxx:70
 AliTRDchamberTimeBin.cxx:71
 AliTRDchamberTimeBin.cxx:72
 AliTRDchamberTimeBin.cxx:73
 AliTRDchamberTimeBin.cxx:74
 AliTRDchamberTimeBin.cxx:75
 AliTRDchamberTimeBin.cxx:76
 AliTRDchamberTimeBin.cxx:77
 AliTRDchamberTimeBin.cxx:78
 AliTRDchamberTimeBin.cxx:79
 AliTRDchamberTimeBin.cxx:80
 AliTRDchamberTimeBin.cxx:81
 AliTRDchamberTimeBin.cxx:82
 AliTRDchamberTimeBin.cxx:83
 AliTRDchamberTimeBin.cxx:84
 AliTRDchamberTimeBin.cxx:85
 AliTRDchamberTimeBin.cxx:86
 AliTRDchamberTimeBin.cxx:87
 AliTRDchamberTimeBin.cxx:88
 AliTRDchamberTimeBin.cxx:89
 AliTRDchamberTimeBin.cxx:90
 AliTRDchamberTimeBin.cxx:91
 AliTRDchamberTimeBin.cxx:92
 AliTRDchamberTimeBin.cxx:93
 AliTRDchamberTimeBin.cxx:94
 AliTRDchamberTimeBin.cxx:95
 AliTRDchamberTimeBin.cxx:96
 AliTRDchamberTimeBin.cxx:97
 AliTRDchamberTimeBin.cxx:98
 AliTRDchamberTimeBin.cxx:99
 AliTRDchamberTimeBin.cxx:100
 AliTRDchamberTimeBin.cxx:101
 AliTRDchamberTimeBin.cxx:102
 AliTRDchamberTimeBin.cxx:103
 AliTRDchamberTimeBin.cxx:104
 AliTRDchamberTimeBin.cxx:105
 AliTRDchamberTimeBin.cxx:106
 AliTRDchamberTimeBin.cxx:107
 AliTRDchamberTimeBin.cxx:108
 AliTRDchamberTimeBin.cxx:109
 AliTRDchamberTimeBin.cxx:110
 AliTRDchamberTimeBin.cxx:111
 AliTRDchamberTimeBin.cxx:112
 AliTRDchamberTimeBin.cxx:113
 AliTRDchamberTimeBin.cxx:114
 AliTRDchamberTimeBin.cxx:115
 AliTRDchamberTimeBin.cxx:116
 AliTRDchamberTimeBin.cxx:117
 AliTRDchamberTimeBin.cxx:118
 AliTRDchamberTimeBin.cxx:119
 AliTRDchamberTimeBin.cxx:120
 AliTRDchamberTimeBin.cxx:121
 AliTRDchamberTimeBin.cxx:122
 AliTRDchamberTimeBin.cxx:123
 AliTRDchamberTimeBin.cxx:124
 AliTRDchamberTimeBin.cxx:125
 AliTRDchamberTimeBin.cxx:126
 AliTRDchamberTimeBin.cxx:127
 AliTRDchamberTimeBin.cxx:128
 AliTRDchamberTimeBin.cxx:129
 AliTRDchamberTimeBin.cxx:130
 AliTRDchamberTimeBin.cxx:131
 AliTRDchamberTimeBin.cxx:132
 AliTRDchamberTimeBin.cxx:133
 AliTRDchamberTimeBin.cxx:134
 AliTRDchamberTimeBin.cxx:135
 AliTRDchamberTimeBin.cxx:136
 AliTRDchamberTimeBin.cxx:137
 AliTRDchamberTimeBin.cxx:138
 AliTRDchamberTimeBin.cxx:139
 AliTRDchamberTimeBin.cxx:140
 AliTRDchamberTimeBin.cxx:141
 AliTRDchamberTimeBin.cxx:142
 AliTRDchamberTimeBin.cxx:143
 AliTRDchamberTimeBin.cxx:144
 AliTRDchamberTimeBin.cxx:145
 AliTRDchamberTimeBin.cxx:146
 AliTRDchamberTimeBin.cxx:147
 AliTRDchamberTimeBin.cxx:148
 AliTRDchamberTimeBin.cxx:149
 AliTRDchamberTimeBin.cxx:150
 AliTRDchamberTimeBin.cxx:151
 AliTRDchamberTimeBin.cxx:152
 AliTRDchamberTimeBin.cxx:153
 AliTRDchamberTimeBin.cxx:154
 AliTRDchamberTimeBin.cxx:155
 AliTRDchamberTimeBin.cxx:156
 AliTRDchamberTimeBin.cxx:157
 AliTRDchamberTimeBin.cxx:158
 AliTRDchamberTimeBin.cxx:159
 AliTRDchamberTimeBin.cxx:160
 AliTRDchamberTimeBin.cxx:161
 AliTRDchamberTimeBin.cxx:162
 AliTRDchamberTimeBin.cxx:163
 AliTRDchamberTimeBin.cxx:164
 AliTRDchamberTimeBin.cxx:165
 AliTRDchamberTimeBin.cxx:166
 AliTRDchamberTimeBin.cxx:167
 AliTRDchamberTimeBin.cxx:168
 AliTRDchamberTimeBin.cxx:169
 AliTRDchamberTimeBin.cxx:170
 AliTRDchamberTimeBin.cxx:171
 AliTRDchamberTimeBin.cxx:172
 AliTRDchamberTimeBin.cxx:173
 AliTRDchamberTimeBin.cxx:174
 AliTRDchamberTimeBin.cxx:175
 AliTRDchamberTimeBin.cxx:176
 AliTRDchamberTimeBin.cxx:177
 AliTRDchamberTimeBin.cxx:178
 AliTRDchamberTimeBin.cxx:179
 AliTRDchamberTimeBin.cxx:180
 AliTRDchamberTimeBin.cxx:181
 AliTRDchamberTimeBin.cxx:182
 AliTRDchamberTimeBin.cxx:183
 AliTRDchamberTimeBin.cxx:184
 AliTRDchamberTimeBin.cxx:185
 AliTRDchamberTimeBin.cxx:186
 AliTRDchamberTimeBin.cxx:187
 AliTRDchamberTimeBin.cxx:188
 AliTRDchamberTimeBin.cxx:189
 AliTRDchamberTimeBin.cxx:190
 AliTRDchamberTimeBin.cxx:191
 AliTRDchamberTimeBin.cxx:192
 AliTRDchamberTimeBin.cxx:193
 AliTRDchamberTimeBin.cxx:194
 AliTRDchamberTimeBin.cxx:195
 AliTRDchamberTimeBin.cxx:196
 AliTRDchamberTimeBin.cxx:197
 AliTRDchamberTimeBin.cxx:198
 AliTRDchamberTimeBin.cxx:199
 AliTRDchamberTimeBin.cxx:200
 AliTRDchamberTimeBin.cxx:201
 AliTRDchamberTimeBin.cxx:202
 AliTRDchamberTimeBin.cxx:203
 AliTRDchamberTimeBin.cxx:204
 AliTRDchamberTimeBin.cxx:205
 AliTRDchamberTimeBin.cxx:206
 AliTRDchamberTimeBin.cxx:207
 AliTRDchamberTimeBin.cxx:208
 AliTRDchamberTimeBin.cxx:209
 AliTRDchamberTimeBin.cxx:210
 AliTRDchamberTimeBin.cxx:211
 AliTRDchamberTimeBin.cxx:212
 AliTRDchamberTimeBin.cxx:213
 AliTRDchamberTimeBin.cxx:214
 AliTRDchamberTimeBin.cxx:215
 AliTRDchamberTimeBin.cxx:216
 AliTRDchamberTimeBin.cxx:217
 AliTRDchamberTimeBin.cxx:218
 AliTRDchamberTimeBin.cxx:219
 AliTRDchamberTimeBin.cxx:220
 AliTRDchamberTimeBin.cxx:221
 AliTRDchamberTimeBin.cxx:222
 AliTRDchamberTimeBin.cxx:223
 AliTRDchamberTimeBin.cxx:224
 AliTRDchamberTimeBin.cxx:225
 AliTRDchamberTimeBin.cxx:226
 AliTRDchamberTimeBin.cxx:227
 AliTRDchamberTimeBin.cxx:228
 AliTRDchamberTimeBin.cxx:229
 AliTRDchamberTimeBin.cxx:230
 AliTRDchamberTimeBin.cxx:231
 AliTRDchamberTimeBin.cxx:232
 AliTRDchamberTimeBin.cxx:233
 AliTRDchamberTimeBin.cxx:234
 AliTRDchamberTimeBin.cxx:235
 AliTRDchamberTimeBin.cxx:236
 AliTRDchamberTimeBin.cxx:237
 AliTRDchamberTimeBin.cxx:238
 AliTRDchamberTimeBin.cxx:239
 AliTRDchamberTimeBin.cxx:240
 AliTRDchamberTimeBin.cxx:241
 AliTRDchamberTimeBin.cxx:242
 AliTRDchamberTimeBin.cxx:243
 AliTRDchamberTimeBin.cxx:244
 AliTRDchamberTimeBin.cxx:245
 AliTRDchamberTimeBin.cxx:246
 AliTRDchamberTimeBin.cxx:247
 AliTRDchamberTimeBin.cxx:248
 AliTRDchamberTimeBin.cxx:249
 AliTRDchamberTimeBin.cxx:250
 AliTRDchamberTimeBin.cxx:251
 AliTRDchamberTimeBin.cxx:252
 AliTRDchamberTimeBin.cxx:253
 AliTRDchamberTimeBin.cxx:254
 AliTRDchamberTimeBin.cxx:255
 AliTRDchamberTimeBin.cxx:256
 AliTRDchamberTimeBin.cxx:257
 AliTRDchamberTimeBin.cxx:258
 AliTRDchamberTimeBin.cxx:259
 AliTRDchamberTimeBin.cxx:260
 AliTRDchamberTimeBin.cxx:261
 AliTRDchamberTimeBin.cxx:262
 AliTRDchamberTimeBin.cxx:263
 AliTRDchamberTimeBin.cxx:264
 AliTRDchamberTimeBin.cxx:265
 AliTRDchamberTimeBin.cxx:266
 AliTRDchamberTimeBin.cxx:267
 AliTRDchamberTimeBin.cxx:268
 AliTRDchamberTimeBin.cxx:269
 AliTRDchamberTimeBin.cxx:270
 AliTRDchamberTimeBin.cxx:271
 AliTRDchamberTimeBin.cxx:272
 AliTRDchamberTimeBin.cxx:273
 AliTRDchamberTimeBin.cxx:274
 AliTRDchamberTimeBin.cxx:275
 AliTRDchamberTimeBin.cxx:276
 AliTRDchamberTimeBin.cxx:277
 AliTRDchamberTimeBin.cxx:278
 AliTRDchamberTimeBin.cxx:279
 AliTRDchamberTimeBin.cxx:280
 AliTRDchamberTimeBin.cxx:281
 AliTRDchamberTimeBin.cxx:282
 AliTRDchamberTimeBin.cxx:283
 AliTRDchamberTimeBin.cxx:284
 AliTRDchamberTimeBin.cxx:285
 AliTRDchamberTimeBin.cxx:286
 AliTRDchamberTimeBin.cxx:287
 AliTRDchamberTimeBin.cxx:288
 AliTRDchamberTimeBin.cxx:289
 AliTRDchamberTimeBin.cxx:290
 AliTRDchamberTimeBin.cxx:291
 AliTRDchamberTimeBin.cxx:292
 AliTRDchamberTimeBin.cxx:293
 AliTRDchamberTimeBin.cxx:294
 AliTRDchamberTimeBin.cxx:295
 AliTRDchamberTimeBin.cxx:296
 AliTRDchamberTimeBin.cxx:297
 AliTRDchamberTimeBin.cxx:298
 AliTRDchamberTimeBin.cxx:299
 AliTRDchamberTimeBin.cxx:300
 AliTRDchamberTimeBin.cxx:301
 AliTRDchamberTimeBin.cxx:302
 AliTRDchamberTimeBin.cxx:303
 AliTRDchamberTimeBin.cxx:304
 AliTRDchamberTimeBin.cxx:305
 AliTRDchamberTimeBin.cxx:306
 AliTRDchamberTimeBin.cxx:307
 AliTRDchamberTimeBin.cxx:308
 AliTRDchamberTimeBin.cxx:309
 AliTRDchamberTimeBin.cxx:310
 AliTRDchamberTimeBin.cxx:311
 AliTRDchamberTimeBin.cxx:312
 AliTRDchamberTimeBin.cxx:313
 AliTRDchamberTimeBin.cxx:314
 AliTRDchamberTimeBin.cxx:315
 AliTRDchamberTimeBin.cxx:316
 AliTRDchamberTimeBin.cxx:317
 AliTRDchamberTimeBin.cxx:318
 AliTRDchamberTimeBin.cxx:319
 AliTRDchamberTimeBin.cxx:320
 AliTRDchamberTimeBin.cxx:321
 AliTRDchamberTimeBin.cxx:322
 AliTRDchamberTimeBin.cxx:323
 AliTRDchamberTimeBin.cxx:324
 AliTRDchamberTimeBin.cxx:325
 AliTRDchamberTimeBin.cxx:326
 AliTRDchamberTimeBin.cxx:327
 AliTRDchamberTimeBin.cxx:328
 AliTRDchamberTimeBin.cxx:329
 AliTRDchamberTimeBin.cxx:330
 AliTRDchamberTimeBin.cxx:331
 AliTRDchamberTimeBin.cxx:332
 AliTRDchamberTimeBin.cxx:333
 AliTRDchamberTimeBin.cxx:334
 AliTRDchamberTimeBin.cxx:335
 AliTRDchamberTimeBin.cxx:336
 AliTRDchamberTimeBin.cxx:337
 AliTRDchamberTimeBin.cxx:338
 AliTRDchamberTimeBin.cxx:339
 AliTRDchamberTimeBin.cxx:340
 AliTRDchamberTimeBin.cxx:341
 AliTRDchamberTimeBin.cxx:342
 AliTRDchamberTimeBin.cxx:343
 AliTRDchamberTimeBin.cxx:344
 AliTRDchamberTimeBin.cxx:345
 AliTRDchamberTimeBin.cxx:346
 AliTRDchamberTimeBin.cxx:347
 AliTRDchamberTimeBin.cxx:348
 AliTRDchamberTimeBin.cxx:349
 AliTRDchamberTimeBin.cxx:350
 AliTRDchamberTimeBin.cxx:351
 AliTRDchamberTimeBin.cxx:352
 AliTRDchamberTimeBin.cxx:353
 AliTRDchamberTimeBin.cxx:354
 AliTRDchamberTimeBin.cxx:355
 AliTRDchamberTimeBin.cxx:356
 AliTRDchamberTimeBin.cxx:357
 AliTRDchamberTimeBin.cxx:358
 AliTRDchamberTimeBin.cxx:359
 AliTRDchamberTimeBin.cxx:360
 AliTRDchamberTimeBin.cxx:361
 AliTRDchamberTimeBin.cxx:362
 AliTRDchamberTimeBin.cxx:363
 AliTRDchamberTimeBin.cxx:364
 AliTRDchamberTimeBin.cxx:365
 AliTRDchamberTimeBin.cxx:366
 AliTRDchamberTimeBin.cxx:367
 AliTRDchamberTimeBin.cxx:368
 AliTRDchamberTimeBin.cxx:369
 AliTRDchamberTimeBin.cxx:370
 AliTRDchamberTimeBin.cxx:371
 AliTRDchamberTimeBin.cxx:372
 AliTRDchamberTimeBin.cxx:373
 AliTRDchamberTimeBin.cxx:374
 AliTRDchamberTimeBin.cxx:375
 AliTRDchamberTimeBin.cxx:376
 AliTRDchamberTimeBin.cxx:377
 AliTRDchamberTimeBin.cxx:378
 AliTRDchamberTimeBin.cxx:379
 AliTRDchamberTimeBin.cxx:380
 AliTRDchamberTimeBin.cxx:381
 AliTRDchamberTimeBin.cxx:382
 AliTRDchamberTimeBin.cxx:383
 AliTRDchamberTimeBin.cxx:384
 AliTRDchamberTimeBin.cxx:385
 AliTRDchamberTimeBin.cxx:386
 AliTRDchamberTimeBin.cxx:387
 AliTRDchamberTimeBin.cxx:388
 AliTRDchamberTimeBin.cxx:389
 AliTRDchamberTimeBin.cxx:390
 AliTRDchamberTimeBin.cxx:391
 AliTRDchamberTimeBin.cxx:392
 AliTRDchamberTimeBin.cxx:393
 AliTRDchamberTimeBin.cxx:394
 AliTRDchamberTimeBin.cxx:395
 AliTRDchamberTimeBin.cxx:396
 AliTRDchamberTimeBin.cxx:397
 AliTRDchamberTimeBin.cxx:398
 AliTRDchamberTimeBin.cxx:399
 AliTRDchamberTimeBin.cxx:400
 AliTRDchamberTimeBin.cxx:401
 AliTRDchamberTimeBin.cxx:402
 AliTRDchamberTimeBin.cxx:403
 AliTRDchamberTimeBin.cxx:404
 AliTRDchamberTimeBin.cxx:405
 AliTRDchamberTimeBin.cxx:406
 AliTRDchamberTimeBin.cxx:407
 AliTRDchamberTimeBin.cxx:408
 AliTRDchamberTimeBin.cxx:409
 AliTRDchamberTimeBin.cxx:410
 AliTRDchamberTimeBin.cxx:411
 AliTRDchamberTimeBin.cxx:412
 AliTRDchamberTimeBin.cxx:413
 AliTRDchamberTimeBin.cxx:414
 AliTRDchamberTimeBin.cxx:415
 AliTRDchamberTimeBin.cxx:416
 AliTRDchamberTimeBin.cxx:417
 AliTRDchamberTimeBin.cxx:418
 AliTRDchamberTimeBin.cxx:419
 AliTRDchamberTimeBin.cxx:420
 AliTRDchamberTimeBin.cxx:421
 AliTRDchamberTimeBin.cxx:422
 AliTRDchamberTimeBin.cxx:423
 AliTRDchamberTimeBin.cxx:424
 AliTRDchamberTimeBin.cxx:425
 AliTRDchamberTimeBin.cxx:426
 AliTRDchamberTimeBin.cxx:427
 AliTRDchamberTimeBin.cxx:428
 AliTRDchamberTimeBin.cxx:429
 AliTRDchamberTimeBin.cxx:430
 AliTRDchamberTimeBin.cxx:431
 AliTRDchamberTimeBin.cxx:432
 AliTRDchamberTimeBin.cxx:433
 AliTRDchamberTimeBin.cxx:434
 AliTRDchamberTimeBin.cxx:435
 AliTRDchamberTimeBin.cxx:436
 AliTRDchamberTimeBin.cxx:437
 AliTRDchamberTimeBin.cxx:438
 AliTRDchamberTimeBin.cxx:439
 AliTRDchamberTimeBin.cxx:440
 AliTRDchamberTimeBin.cxx:441
 AliTRDchamberTimeBin.cxx:442
 AliTRDchamberTimeBin.cxx:443
 AliTRDchamberTimeBin.cxx:444
 AliTRDchamberTimeBin.cxx:445
 AliTRDchamberTimeBin.cxx:446
 AliTRDchamberTimeBin.cxx:447
 AliTRDchamberTimeBin.cxx:448
 AliTRDchamberTimeBin.cxx:449
 AliTRDchamberTimeBin.cxx:450
 AliTRDchamberTimeBin.cxx:451
 AliTRDchamberTimeBin.cxx:452
 AliTRDchamberTimeBin.cxx:453
 AliTRDchamberTimeBin.cxx:454
 AliTRDchamberTimeBin.cxx:455
 AliTRDchamberTimeBin.cxx:456
 AliTRDchamberTimeBin.cxx:457
 AliTRDchamberTimeBin.cxx:458
 AliTRDchamberTimeBin.cxx:459
 AliTRDchamberTimeBin.cxx:460
 AliTRDchamberTimeBin.cxx:461
 AliTRDchamberTimeBin.cxx:462
 AliTRDchamberTimeBin.cxx:463
 AliTRDchamberTimeBin.cxx:464
 AliTRDchamberTimeBin.cxx:465
 AliTRDchamberTimeBin.cxx:466
 AliTRDchamberTimeBin.cxx:467
 AliTRDchamberTimeBin.cxx:468
 AliTRDchamberTimeBin.cxx:469
 AliTRDchamberTimeBin.cxx:470
 AliTRDchamberTimeBin.cxx:471
 AliTRDchamberTimeBin.cxx:472
 AliTRDchamberTimeBin.cxx:473
 AliTRDchamberTimeBin.cxx:474
 AliTRDchamberTimeBin.cxx:475
 AliTRDchamberTimeBin.cxx:476
 AliTRDchamberTimeBin.cxx:477
 AliTRDchamberTimeBin.cxx:478
 AliTRDchamberTimeBin.cxx:479
 AliTRDchamberTimeBin.cxx:480
 AliTRDchamberTimeBin.cxx:481
 AliTRDchamberTimeBin.cxx:482
 AliTRDchamberTimeBin.cxx:483
 AliTRDchamberTimeBin.cxx:484
 AliTRDchamberTimeBin.cxx:485
 AliTRDchamberTimeBin.cxx:486
 AliTRDchamberTimeBin.cxx:487
 AliTRDchamberTimeBin.cxx:488
 AliTRDchamberTimeBin.cxx:489
 AliTRDchamberTimeBin.cxx:490
 AliTRDchamberTimeBin.cxx:491
 AliTRDchamberTimeBin.cxx:492
 AliTRDchamberTimeBin.cxx:493
 AliTRDchamberTimeBin.cxx:494
 AliTRDchamberTimeBin.cxx:495
 AliTRDchamberTimeBin.cxx:496
 AliTRDchamberTimeBin.cxx:497
 AliTRDchamberTimeBin.cxx:498
 AliTRDchamberTimeBin.cxx:499
 AliTRDchamberTimeBin.cxx:500
 AliTRDchamberTimeBin.cxx:501
 AliTRDchamberTimeBin.cxx:502
 AliTRDchamberTimeBin.cxx:503
 AliTRDchamberTimeBin.cxx:504
 AliTRDchamberTimeBin.cxx:505
 AliTRDchamberTimeBin.cxx:506
 AliTRDchamberTimeBin.cxx:507
 AliTRDchamberTimeBin.cxx:508
 AliTRDchamberTimeBin.cxx:509
 AliTRDchamberTimeBin.cxx:510
 AliTRDchamberTimeBin.cxx:511
 AliTRDchamberTimeBin.cxx:512
 AliTRDchamberTimeBin.cxx:513
 AliTRDchamberTimeBin.cxx:514
 AliTRDchamberTimeBin.cxx:515
 AliTRDchamberTimeBin.cxx:516
 AliTRDchamberTimeBin.cxx:517
 AliTRDchamberTimeBin.cxx:518
 AliTRDchamberTimeBin.cxx:519
 AliTRDchamberTimeBin.cxx:520
 AliTRDchamberTimeBin.cxx:521
 AliTRDchamberTimeBin.cxx:522
 AliTRDchamberTimeBin.cxx:523
 AliTRDchamberTimeBin.cxx:524
 AliTRDchamberTimeBin.cxx:525
 AliTRDchamberTimeBin.cxx:526
 AliTRDchamberTimeBin.cxx:527
 AliTRDchamberTimeBin.cxx:528
 AliTRDchamberTimeBin.cxx:529
 AliTRDchamberTimeBin.cxx:530
 AliTRDchamberTimeBin.cxx:531
 AliTRDchamberTimeBin.cxx:532
 AliTRDchamberTimeBin.cxx:533
 AliTRDchamberTimeBin.cxx:534
 AliTRDchamberTimeBin.cxx:535
 AliTRDchamberTimeBin.cxx:536
 AliTRDchamberTimeBin.cxx:537
 AliTRDchamberTimeBin.cxx:538
 AliTRDchamberTimeBin.cxx:539
 AliTRDchamberTimeBin.cxx:540
 AliTRDchamberTimeBin.cxx:541
 AliTRDchamberTimeBin.cxx:542
 AliTRDchamberTimeBin.cxx:543
 AliTRDchamberTimeBin.cxx:544
 AliTRDchamberTimeBin.cxx:545
 AliTRDchamberTimeBin.cxx:546
 AliTRDchamberTimeBin.cxx:547
 AliTRDchamberTimeBin.cxx:548
 AliTRDchamberTimeBin.cxx:549
 AliTRDchamberTimeBin.cxx:550
 AliTRDchamberTimeBin.cxx:551
 AliTRDchamberTimeBin.cxx:552
 AliTRDchamberTimeBin.cxx:553
 AliTRDchamberTimeBin.cxx:554
 AliTRDchamberTimeBin.cxx:555
 AliTRDchamberTimeBin.cxx:556
 AliTRDchamberTimeBin.cxx:557
 AliTRDchamberTimeBin.cxx:558
 AliTRDchamberTimeBin.cxx:559
 AliTRDchamberTimeBin.cxx:560
 AliTRDchamberTimeBin.cxx:561
 AliTRDchamberTimeBin.cxx:562
 AliTRDchamberTimeBin.cxx:563
 AliTRDchamberTimeBin.cxx:564
 AliTRDchamberTimeBin.cxx:565
 AliTRDchamberTimeBin.cxx:566
 AliTRDchamberTimeBin.cxx:567
 AliTRDchamberTimeBin.cxx:568
 AliTRDchamberTimeBin.cxx:569
 AliTRDchamberTimeBin.cxx:570
 AliTRDchamberTimeBin.cxx:571
 AliTRDchamberTimeBin.cxx:572
 AliTRDchamberTimeBin.cxx:573
 AliTRDchamberTimeBin.cxx:574
 AliTRDchamberTimeBin.cxx:575
 AliTRDchamberTimeBin.cxx:576
 AliTRDchamberTimeBin.cxx:577
 AliTRDchamberTimeBin.cxx:578
 AliTRDchamberTimeBin.cxx:579
 AliTRDchamberTimeBin.cxx:580
 AliTRDchamberTimeBin.cxx:581
 AliTRDchamberTimeBin.cxx:582
 AliTRDchamberTimeBin.cxx:583
 AliTRDchamberTimeBin.cxx:584
 AliTRDchamberTimeBin.cxx:585
 AliTRDchamberTimeBin.cxx:586
 AliTRDchamberTimeBin.cxx:587
 AliTRDchamberTimeBin.cxx:588
 AliTRDchamberTimeBin.cxx:589
 AliTRDchamberTimeBin.cxx:590
 AliTRDchamberTimeBin.cxx:591
 AliTRDchamberTimeBin.cxx:592
 AliTRDchamberTimeBin.cxx:593
 AliTRDchamberTimeBin.cxx:594
 AliTRDchamberTimeBin.cxx:595
 AliTRDchamberTimeBin.cxx:596
 AliTRDchamberTimeBin.cxx:597
 AliTRDchamberTimeBin.cxx:598
 AliTRDchamberTimeBin.cxx:599
 AliTRDchamberTimeBin.cxx:600
 AliTRDchamberTimeBin.cxx:601
 AliTRDchamberTimeBin.cxx:602
 AliTRDchamberTimeBin.cxx:603
 AliTRDchamberTimeBin.cxx:604
 AliTRDchamberTimeBin.cxx:605
 AliTRDchamberTimeBin.cxx:606
 AliTRDchamberTimeBin.cxx:607
 AliTRDchamberTimeBin.cxx:608
 AliTRDchamberTimeBin.cxx:609
 AliTRDchamberTimeBin.cxx:610
 AliTRDchamberTimeBin.cxx:611
 AliTRDchamberTimeBin.cxx:612
 AliTRDchamberTimeBin.cxx:613
 AliTRDchamberTimeBin.cxx:614
 AliTRDchamberTimeBin.cxx:615
 AliTRDchamberTimeBin.cxx:616
 AliTRDchamberTimeBin.cxx:617
 AliTRDchamberTimeBin.cxx:618
 AliTRDchamberTimeBin.cxx:619
 AliTRDchamberTimeBin.cxx:620
 AliTRDchamberTimeBin.cxx:621
 AliTRDchamberTimeBin.cxx:622
 AliTRDchamberTimeBin.cxx:623
 AliTRDchamberTimeBin.cxx:624
 AliTRDchamberTimeBin.cxx:625
 AliTRDchamberTimeBin.cxx:626
 AliTRDchamberTimeBin.cxx:627
 AliTRDchamberTimeBin.cxx:628
 AliTRDchamberTimeBin.cxx:629
 AliTRDchamberTimeBin.cxx:630
 AliTRDchamberTimeBin.cxx:631
 AliTRDchamberTimeBin.cxx:632
 AliTRDchamberTimeBin.cxx:633
 AliTRDchamberTimeBin.cxx:634
 AliTRDchamberTimeBin.cxx:635
 AliTRDchamberTimeBin.cxx:636
 AliTRDchamberTimeBin.cxx:637
 AliTRDchamberTimeBin.cxx:638
 AliTRDchamberTimeBin.cxx:639
 AliTRDchamberTimeBin.cxx:640
 AliTRDchamberTimeBin.cxx:641
 AliTRDchamberTimeBin.cxx:642
 AliTRDchamberTimeBin.cxx:643
 AliTRDchamberTimeBin.cxx:644
 AliTRDchamberTimeBin.cxx:645
 AliTRDchamberTimeBin.cxx:646
 AliTRDchamberTimeBin.cxx:647
 AliTRDchamberTimeBin.cxx:648
 AliTRDchamberTimeBin.cxx:649
 AliTRDchamberTimeBin.cxx:650
 AliTRDchamberTimeBin.cxx:651
 AliTRDchamberTimeBin.cxx:652
 AliTRDchamberTimeBin.cxx:653
 AliTRDchamberTimeBin.cxx:654
 AliTRDchamberTimeBin.cxx:655
 AliTRDchamberTimeBin.cxx:656
 AliTRDchamberTimeBin.cxx:657
 AliTRDchamberTimeBin.cxx:658
 AliTRDchamberTimeBin.cxx:659
 AliTRDchamberTimeBin.cxx:660
 AliTRDchamberTimeBin.cxx:661
 AliTRDchamberTimeBin.cxx:662
 AliTRDchamberTimeBin.cxx:663
 AliTRDchamberTimeBin.cxx:664
 AliTRDchamberTimeBin.cxx:665
 AliTRDchamberTimeBin.cxx:666
 AliTRDchamberTimeBin.cxx:667
 AliTRDchamberTimeBin.cxx:668
 AliTRDchamberTimeBin.cxx:669
 AliTRDchamberTimeBin.cxx:670
 AliTRDchamberTimeBin.cxx:671
 AliTRDchamberTimeBin.cxx:672
 AliTRDchamberTimeBin.cxx:673
 AliTRDchamberTimeBin.cxx:674
 AliTRDchamberTimeBin.cxx:675
 AliTRDchamberTimeBin.cxx:676