running local for SP and LYZEP and new histograms for QC
[u/mrichter/AliRoot.git] / TRD / AliTRDseedV1.cxx
index b0550e6..7db2412 100644 (file)
@@ -1,17 +1,17 @@
 /**************************************************************************
- * 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.                  *
- **************************************************************************/
+* 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$ */
 
 
 #include "TMath.h"
 #include "TLinearFitter.h"
+#include "TClonesArray.h" // tmp
+#include <TTreeStream.h>
 
 #include "AliLog.h"
 #include "AliMathBase.h"
+#include "AliCDBManager.h"
+#include "AliTracker.h"
 
-#include "AliTRDseedV1.h"
+#include "AliTRDpadPlane.h"
 #include "AliTRDcluster.h"
-#include "AliTRDtrack.h"
+#include "AliTRDseedV1.h"
+#include "AliTRDtrackV1.h"
 #include "AliTRDcalibDB.h"
-#include "AliTRDstackLayer.h"
+#include "AliTRDchamberTimeBin.h"
+#include "AliTRDtrackingChamber.h"
+#include "AliTRDtrackerV1.h"
+#include "AliTRDReconstructor.h"
 #include "AliTRDrecoParam.h"
-#include "AliTRDgeometry.h"
-#include "Cal/AliTRDCalPID.h"
 
-#define SEED_DEBUG
+#include "Cal/AliTRDCalPID.h"
+#include "Cal/AliTRDCalROC.h"
+#include "Cal/AliTRDCalDet.h"
 
 ClassImp(AliTRDseedV1)
 
 //____________________________________________________________________
-AliTRDseedV1::AliTRDseedV1(Int_t layer, AliTRDrecoParam *p) 
+AliTRDseedV1::AliTRDseedV1(Int_t det) 
   :AliTRDseed()
-  ,fPlane(layer)
-  ,fOwner(kFALSE)
+  ,fReconstructor(0x0)
+  ,fClusterIter(0x0)
+  ,fClusterIdx(0)
+  ,fDet(det)
   ,fMom(0.)
-  ,fRecoParam(p)
+  ,fSnp(0.)
+  ,fTgl(0.)
+  ,fdX(0.)
+  ,fXref(0.)
+  ,fExB(0.)
 {
   //
   // Constructor
   //
-       for(int islice=0; islice < knSlices; islice++) fdEdx[islice] = 0.;
-       for(int itb=0; itb < knTimebins; itb++){
-               fdQdl[itb]  = 0.;
-               fdQ[itb]    = 0.;
-       }
-       for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) fProb[ispec]  = -1.;
+  for(int islice=0; islice < knSlices; islice++) fdEdx[islice] = 0.;
+  for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) fProb[ispec]  = -1.;
+  fRefCov[0] = 1.; fRefCov[1] = 0.; fRefCov[2] = 1.;
+  // covariance matrix [diagonal]
+  // default sy = 200um and sz = 2.3 cm 
+  fCov[0] = 4.e-4; fCov[1] = 0.; fCov[2] = 5.3; 
 }
 
 //____________________________________________________________________
 AliTRDseedV1::AliTRDseedV1(const AliTRDseedV1 &ref)
   :AliTRDseed((AliTRDseed&)ref)
-  ,fPlane(ref.fPlane)
-  ,fOwner(kFALSE)
+  ,fReconstructor(ref.fReconstructor)
+  ,fClusterIter(0x0)
+  ,fClusterIdx(0)
+  ,fDet(ref.fDet)
   ,fMom(ref.fMom)
-  ,fRecoParam(ref.fRecoParam)
+  ,fSnp(ref.fSnp)
+  ,fTgl(ref.fTgl)
+  ,fdX(ref.fdX)
+  ,fXref(ref.fXref)
+  ,fExB(ref.fExB)
 {
   //
   // Copy Constructor performing a deep copy
   //
 
-       //AliInfo("");
-       if(ref.fOwner) SetOwner();
-       for(int islice=0; islice < knSlices; islice++) fdEdx[islice] = ref.fdEdx[islice];
-       for(int itb=0; itb < knTimebins; itb++){ 
-               fdQdl[itb] = ref.fdQdl[itb];
-               fdQ[itb]   = ref.fdQ[itb];
-       }
-       for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) fProb[ispec] = ref.fProb[ispec];
+  //printf("AliTRDseedV1::AliTRDseedV1(const AliTRDseedV1 &)\n");
+  SetBit(kOwner, kFALSE);
+  for(int islice=0; islice < knSlices; islice++) fdEdx[islice] = ref.fdEdx[islice];
+  for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) fProb[ispec] = ref.fProb[ispec];
+  memcpy(fRefCov, ref.fRefCov, 3*sizeof(Double_t));
+  memcpy(fCov, ref.fCov, 3*sizeof(Double_t));
 }
 
 
@@ -93,11 +111,12 @@ AliTRDseedV1& AliTRDseedV1::operator=(const AliTRDseedV1 &ref)
   // Assignment Operator using the copy function
   //
 
-       //AliInfo("");
-       if(this != &ref){
-               ref.Copy(*this);
-       }
-       return *this;
+  if(this != &ref){
+    ref.Copy(*this);
+  }
+  SetBit(kOwner, kFALSE);
+
+  return *this;
 
 }
 
@@ -108,15 +127,15 @@ AliTRDseedV1::~AliTRDseedV1()
   // Destructor. The RecoParam object belongs to the underlying tracker.
   //
 
-       //AliInfo(Form("fOwner[%s]", fOwner?"YES":"NO"));
+  //printf("I-AliTRDseedV1::~AliTRDseedV1() : Owner[%s]\n", IsOwner()?"YES":"NO");
 
-       if(fOwner) 
-               for(int itb=0; itb<knTimebins; itb++){
-                       if(!fClusters[itb]) continue; 
-                       //AliInfo(Form("deleting c %p @ %d", fClusters[itb], itb));
-                       delete fClusters[itb];
-                       fClusters[itb] = 0x0;
-               }
+  if(IsOwner()) 
+    for(int itb=0; itb<knTimebins; itb++){
+      if(!fClusters[itb]) continue; 
+      //AliInfo(Form("deleting c %p @ %d", fClusters[itb], itb));
+      delete fClusters[itb];
+      fClusters[itb] = 0x0;
+    }
 }
 
 //____________________________________________________________________
@@ -126,26 +145,31 @@ void AliTRDseedV1::Copy(TObject &ref) const
   // Copy function
   //
 
-       //AliInfo("");
-       AliTRDseedV1 &target = (AliTRDseedV1 &)ref; 
-       
-       target.fPlane         = fPlane;
-       target.fMom           = fMom;
-       target.fRecoParam     = fRecoParam;
-       
-       for(int islice=0; islice < knSlices; islice++) target.fdEdx[islice] = fdEdx[islice];
-       for(int itb=0; itb < knTimebins; itb++){
-               target.fdQdl[itb] = fdQdl[itb];
-               target.fdQ[itb]   = fdQ[itb];
-       }
-       for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) target.fProb[ispec] = fProb[ispec];
-       
-       AliTRDseed::Copy(target);
+  //AliInfo("");
+  AliTRDseedV1 &target = (AliTRDseedV1 &)ref; 
+
+  target.fClusterIter   = 0x0;
+  target.fClusterIdx    = 0;
+  target.fDet           = fDet;
+  target.fMom           = fMom;
+  target.fSnp           = fSnp;
+  target.fTgl           = fTgl;
+  target.fdX            = fdX;
+  target.fXref          = fXref;
+  target.fExB           = fExB;
+  target.fReconstructor = fReconstructor;
+  
+  for(int islice=0; islice < knSlices; islice++) target.fdEdx[islice] = fdEdx[islice];
+  for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) target.fProb[ispec] = fProb[ispec];
+  memcpy(target.fRefCov, fRefCov, 3*sizeof(Double_t));
+  memcpy(target.fCov, fCov, 3*sizeof(Double_t));
+  
+  AliTRDseed::Copy(target);
 }
 
 
 //____________________________________________________________
-void AliTRDseedV1::Init(AliTRDtrack *track)
+Bool_t AliTRDseedV1::Init(AliTRDtrackV1 *track)
 {
 // Initialize this tracklet using the track information
 //
@@ -161,14 +185,146 @@ void AliTRDseedV1::Init(AliTRDtrack *track)
 // chamber where the tracklet will be constructed
 //
 
-       Double_t y, z; 
-       track->GetProlongation(fX0, y, z);
-       fYref[0] = y;
-       fYref[1] = track->GetSnp()/(1. - track->GetSnp()*track->GetSnp());
-       fZref[0] = z;
-       fZref[1] = track->GetTgl();
+  Double_t y, z; 
+  if(!track->GetProlongation(fX0, y, z)) return kFALSE;
+  UpDate(track);
+  return kTRUE;
+}
+
+
+//____________________________________________________________________
+void AliTRDseedV1::UpDate(const AliTRDtrackV1 *trk)
+{ 
+  // update tracklet reference position from the TRD track
+  // Funny name to avoid the clash with the function AliTRDseed::Update() (has to be made obselete)
+
+  fSnp = trk->GetSnp();
+  fTgl = trk->GetTgl();
+  fMom = trk->GetP();
+  fYref[1] = fSnp/(1. - fSnp*fSnp);
+  fZref[1] = fTgl;
+  SetCovRef(trk->GetCovariance());
+
+  Double_t dx = trk->GetX() - fX0;
+  fYref[0] = trk->GetY() - dx*fYref[1];
+  fZref[0] = trk->GetZ() - dx*fZref[1];
+}
+
+//____________________________________________________________________
+void AliTRDseedV1::CookdEdx(Int_t nslices)
+{
+// Calculates average dE/dx for all slices and store them in the internal array fdEdx. 
+//
+// Parameters:
+//  nslices : number of slices for which dE/dx should be calculated
+// Output:
+//  store results in the internal array fdEdx. This can be accessed with the method
+//  AliTRDseedV1::GetdEdx()
+//
+// Detailed description
+// Calculates average dE/dx for all slices. Depending on the PID methode 
+// the number of slices can be 3 (LQ) or 8(NN). 
+// The calculation of dQ/dl are done using the tracklet fit results (see AliTRDseedV1::GetdQdl(Int_t))
+//
+// The following effects are included in the calculation:
+// 1. calibration values for t0 and vdrift (using x coordinate to calculate slice)
+// 2. cluster sharing (optional see AliTRDrecoParam::SetClusterSharing())
+// 3. cluster size
+//
+
+  Int_t nclusters[knSlices];
+  for(int i=0; i<knSlices; i++){ 
+    fdEdx[i]     = 0.;
+    nclusters[i] = 0;
+  }
+  Float_t pathLength = (.5 * AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
 
-       //printf("Tracklet ref x[%7.3f] y[%7.3f] z[%7.3f], snp[%f] tgl[%f]\n", fX0, fYref[0], fZref[0], track->GetSnp(), track->GetTgl());
+  AliTRDcluster *c = 0x0;
+  for(int ic=0; ic<AliTRDtrackerV1::GetNTimeBins(); ic++){
+    if(!(c = fClusters[ic]) && !(c = fClusters[ic+kNtb])) continue;
+    Float_t x = c->GetX();
+    
+    // Filter clusters for dE/dx calculation
+    
+    // 1.consider calibration effects for slice determination
+    Int_t slice; 
+    if(c->IsInChamber()) slice = Int_t(TMath::Abs(fX0 - x) * nslices / pathLength);
+    else slice = x < fX0 ? 0 : nslices-1;
+    
+    // 2. take sharing into account
+    Float_t w = c->IsShared() ? .5 : 1.;
+    
+    // 3. take into account large clusters TODO
+    //w *= c->GetNPads() > 3 ? .8 : 1.;
+    
+    //CHECK !!!
+    fdEdx[slice]   += w * GetdQdl(ic); //fdQdl[ic];
+    nclusters[slice]++;
+  } // End of loop over clusters
+
+  //if(fReconstructor->GetPIDMethod() == AliTRDReconstructor::kLQPID){
+  if(nslices == AliTRDReconstructor::kLQslices){
+  // calculate mean charge per slice (only LQ PID)
+    for(int is=0; is<nslices; is++){ 
+      if(nclusters[is]) fdEdx[is] /= nclusters[is];
+    }
+  }
+}
+
+//____________________________________________________________________
+void AliTRDseedV1::GetClusterXY(const AliTRDcluster *c, Double_t &x, Double_t &y)
+{
+// Return corrected position of the cluster taking into 
+// account variation of the drift velocity with drift length.
+
+
+  // drift velocity correction TODO to be moved to the clusterizer
+  const Float_t cx[] = {
+    -9.6280e-02, 1.3091e-01,-1.7415e-02,-9.9221e-02,-1.2040e-01,-9.5493e-02,
+    -5.0041e-02,-1.6726e-02, 3.5756e-03, 1.8611e-02, 2.6378e-02, 3.3823e-02,
+     3.4811e-02, 3.5282e-02, 3.5386e-02, 3.6047e-02, 3.5201e-02, 3.4384e-02,
+     3.2864e-02, 3.1932e-02, 3.2051e-02, 2.2539e-02,-2.5154e-02,-1.2050e-01,
+    -1.2050e-01
+  };
+
+  // PRF correction TODO to be replaced by the gaussian 
+  // approximation with full error parametrization and // moved to the clusterizer
+  const Float_t cy[AliTRDgeometry::kNlayer][3] = {
+    { 4.014e-04, 8.605e-03, -6.880e+00},
+    {-3.061e-04, 9.663e-03, -6.789e+00},
+    { 1.124e-03, 1.105e-02, -6.825e+00},
+    {-1.527e-03, 1.231e-02, -6.777e+00},
+    { 2.150e-03, 1.387e-02, -6.783e+00},
+    {-1.296e-03, 1.486e-02, -6.825e+00}
+  }; 
+
+  Int_t ily = AliTRDgeometry::GetLayer(c->GetDetector());
+  x = c->GetX() - cx[c->GetLocalTimeBin()];
+  y = c->GetY() + cy[ily][0] + cy[ily][1] * TMath::Sin(cy[ily][2] * c->GetCenter());
+  return;
+}
+
+//____________________________________________________________________
+Float_t AliTRDseedV1::GetdQdl(Int_t ic) const
+{
+// Using the linear approximation of the track inside one TRD chamber (TRD tracklet) 
+// the charge per unit length can be written as:
+// BEGIN_LATEX
+// #frac{dq}{dl} = #frac{q_{c}}{dx * #sqrt{1 + #(){#frac{dy}{dx}}^{2}_{fit} + #(){#frac{dy}{dx}}^{2}_{ref}}}
+// END_LATEX
+// where qc is the total charge collected in the current time bin and dx is the length 
+// of the time bin. For the moment (Jan 20 2009) only pad row cross corrections are 
+// considered for the charge but none are applied for drift velocity variations along 
+// the drift region or assymetry of the TRF
+// 
+// Author : Alex Bercuci <A.Bercuci@gsi.de>
+//
+  Float_t dq = 0.;
+  if(fClusters[ic]) dq += TMath::Abs(fClusters[ic]->GetQ());
+  if(fClusters[ic+kNtb]) dq += TMath::Abs(fClusters[ic+kNtb]->GetQ());
+  if(dq<1.e-3 || fdX < 1.e-3) return 0.;
+
+  return dq/fdX/TMath::Sqrt(1. + fYfit[1]*fYfit[1] + fZref[1]*fZref[1]);
 }
 
 //____________________________________________________________________
@@ -183,78 +339,40 @@ Double_t* AliTRDseedV1::GetProbability()
 //
 // Detailed description
 
-       
-       // retrive calibration db
+  
+  // retrive calibration db
   AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
   if (!calibration) {
     AliError("No access to calibration data");
     return 0x0;
   }
 
+  if (!fReconstructor) {
+    AliError("Reconstructor not set.");
+    return 0x0;
+  }
+
   // Retrieve the CDB container class with the parametric detector response
-  const AliTRDCalPID *pd = calibration->GetPIDObject(fRecoParam->GetPIDMethod());
+  const AliTRDCalPID *pd = calibration->GetPIDObject(fReconstructor->GetPIDMethod());
   if (!pd) {
     AliError("No access to AliTRDCalPID object");
     return 0x0;
   }
-       
-       // calculate tracklet length TO DO
+  //AliInfo(Form("Method[%d] : %s", fReconstructor->GetRecoParam() ->GetPIDMethod(), pd->IsA()->GetName()));
+
+  // calculate tracklet length TO DO
   Float_t length = (AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
   /// TMath::Sqrt((1.0 - fSnp[iPlane]*fSnp[iPlane]) / (1.0 + fTgl[iPlane]*fTgl[iPlane]));
   
   //calculate dE/dx
-  CookdEdx(fRecoParam->GetNdEdxSlices());
+  CookdEdx(fReconstructor->GetNdEdxSlices());
   
   // Sets the a priori probabilities
   for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) {
-    fProb[ispec] = pd->GetProbability(ispec, fMom, &fdEdx[0], length, fPlane); 
+    fProb[ispec] = pd->GetProbability(ispec, fMom, &fdEdx[0], length, GetPlane());     
   }
 
-       return &fProb[0];
-}
-
-//____________________________________________________________________
-void AliTRDseedV1::CookdEdx(Int_t nslices)
-{
-// Calculates average dE/dx for all slices and store them in the internal array fdEdx. 
-//
-// Parameters:
-//  nslices : number of slices for which dE/dx should be calculated
-// Output:
-//
-// Detailed description
-// Calculates average dE/dx for all slices. Depending on the PID methode 
-// the number of slices can be 3 (LQ) or 8(NN). The calculation is based 
-// on previously calculated quantities dQ/dl of each cluster. The 
-// following effects are included in the calculation:
-// 1. calibration values for t0 and vdrift
-// 2. cluster sharing (optional see AliTRDrecoParam::SetClusterSharing())
-//
-
-       Int_t nclusters[knSlices];
-       for(int i=0; i<knSlices; i++){ 
-               fdEdx[i]     = 0.;
-               nclusters[i] = 0;
-       }
-       
-       AliTRDcluster *cluster = 0x0;
-       for(int ic=0; ic<fgTimeBins; ic++){
-               if(!(cluster = fClusters[ic])) continue;
-               Int_t tb = cluster->GetLocalTimeBin();
-               
-               // consider calibration effects
-               if(tb < fTimeBin0 || tb >= fTimeBin0+fTimeBinsRange) continue;
-       
-               // consider cluster sharing ... TO DO
-               //if(fRecoParam->GetClusterSharing() && cluster->GetSharing()) continue;
-               
-               Int_t slice = (tb-fTimeBin0)*nslices/fTimeBinsRange;
-               fdEdx[slice]   += fdQdl[ic];
-               nclusters[slice]++;
-       } // End of loop over clusters
-
-       // calculate mean charge per slice
-       for(int is=0; is<nslices; is++) if(nclusters[is]) fdEdx[is] /= nclusters[is];
+  return &fProb[0];
 }
 
 //____________________________________________________________________
@@ -264,173 +382,264 @@ Float_t AliTRDseedV1::GetQuality(Bool_t kZcorr) const
   // Returns a quality measurement of the current seed
   //
 
-       Float_t zcorr = kZcorr ? fTilt * (fZProb - fZref[0]) : 0.;
-       return .5 * (18.0 - fN2)
-               + 10.* TMath::Abs(fYfit[1] - fYref[1])
-               + 5.* TMath::Abs(fYfit[0] - fYref[0] + zcorr)
-               + 2. * TMath::Abs(fMeanz - fZref[0]) / fPadLength;
+  Float_t zcorr = kZcorr ? fTilt * (fZProb - fZref[0]) : 0.;
+  return 
+      .5 * TMath::Abs(18.0 - fN2)
+    + 10.* TMath::Abs(fYfit[1] - fYref[1])
+    + 5. * TMath::Abs(fYfit[0] - fYref[0] + zcorr)
+    + 2. * TMath::Abs(fMeanz - fZref[0]) / fPadLength;
 }
 
 //____________________________________________________________________
-void AliTRDseedV1::GetCovAt(Double_t /*x*/, Double_t *cov) const
+void AliTRDseedV1::GetCovAt(Double_t x, Double_t *cov) const
 {
-// Computes covariance in the y-z plane at radial point x
+// Computes covariance in the y-z plane at radial point x (in tracking coordinates) 
+// and returns the results in the preallocated array cov[3] as :
+//   cov[0] = Var(y)
+//   cov[1] = Cov(yz)
+//   cov[2] = Var(z)
+//
+// Details
+//
+// For the linear transformation
+// BEGIN_LATEX
+// Y = T_{x} X^{T}
+// END_LATEX
+//   The error propagation has the general form
+// BEGIN_LATEX
+// C_{Y} = T_{x} C_{X} T_{x}^{T} 
+// END_LATEX
+//  We apply this formula 2 times. First to calculate the covariance of the tracklet 
+// at point x we consider: 
+// BEGIN_LATEX
+// T_{x} = (1 x); X=(y0 dy/dx); C_{X}=#(){#splitline{Var(y0) Cov(y0, dy/dx)}{Cov(y0, dy/dx) Var(dy/dx)}} 
+// END_LATEX
+// and secondly to take into account the tilt angle
+// BEGIN_LATEX
+// T_{#alpha} = #(){#splitline{cos(#alpha) __ sin(#alpha)}{-sin(#alpha) __ cos(#alpha)}}; X=(y z); C_{X}=#(){#splitline{Var(y)    0}{0   Var(z)}} 
+// END_LATEX
+//
+// using simple trigonometrics one can write for this last case
+// BEGIN_LATEX
+// C_{Y}=#frac{1}{1+tg^{2}#alpha} #(){#splitline{(#sigma_{y}^{2}+tg^{2}#alpha#sigma_{z}^{2}) __ tg#alpha(#sigma_{z}^{2}-#sigma_{y}^{2})}{tg#alpha(#sigma_{z}^{2}-#sigma_{y}^{2}) __ (#sigma_{z}^{2}+tg^{2}#alpha#sigma_{y}^{2})}} 
+// END_LATEX
+// which can be aproximated for small alphas (2 deg) with
+// BEGIN_LATEX
+// C_{Y}=#(){#splitline{#sigma_{y}^{2} __ (#sigma_{z}^{2}-#sigma_{y}^{2})tg#alpha}{((#sigma_{z}^{2}-#sigma_{y}^{2})tg#alpha __ #sigma_{z}^{2}}} 
+// END_LATEX
+//
+// before applying the tilt rotation we also apply systematic uncertainties to the tracklet 
+// position which can be tunned from outside via the AliTRDrecoParam::SetSysCovMatrix(). They might 
+// account for extra misalignment/miscalibration uncertainties. 
+//
+// Author :
+// Alex Bercuci <A.Bercuci@gsi.de> 
+// Date : Jan 8th 2009
+//
+
 
-       const Float_t k0= .2; // to be checked in FindClusters
-       Double_t sy20   = k0*TMath::Tan(fYfit[1]); sy20 *= sy20;
-       
-       Double_t sy2    = fSigmaY2*fSigmaY2 + sy20;
-       Double_t sz2    = fPadLength/12.;
+  Double_t xr     = fX0-x; 
+  Double_t sy2    = fCov[0] +2.*xr*fCov[1] + xr*xr*fCov[2];
+  Double_t sz2    = fPadLength*fPadLength/12.;
 
-       //printf("Yfit[1] %f sy20 %f SigmaY2 %f\n", fYfit[1], sy20, fSigmaY2);
+  // insert systematic uncertainties
+  Double_t sys[15];
+  fReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
+  sy2 += sys[0];
+  sz2 += sys[1];
 
-       cov[0] = sy2;
-       cov[1] = fTilt*(sy2-sz2);
-       cov[2] = sz2;
+  // rotate covariance matrix
+  Double_t t2 = fTilt*fTilt;
+  Double_t correction = 1./(1. + t2);
+  cov[0] = (sy2+t2*sz2)*correction;
+  cov[1] = fTilt*(sz2 - sy2)*correction;
+  cov[2] = (t2*sy2+sz2)*correction;
 }
 
+
 //____________________________________________________________________
-void AliTRDseedV1::SetdQdl(Double_t length)
+void AliTRDseedV1::SetExB()
 {
-       for(int ic=0; ic<fgTimeBins; ic++) fdQdl[ic] = fdQ[ic] *length;
+// Retrive the tg(a_L) from OCDB. The following information are used
+//  - detector index
+//  - column and row position of first attached cluster. 
+// 
+// If no clusters are attached to the tracklet a random central chamber 
+// position (c=70, r=7) will be used to retrieve the drift velocity.
+//
+// Author :
+// Alex Bercuci <A.Bercuci@gsi.de> 
+// Date : Jan 8th 2009
+//
+
+  AliCDBManager *cdb = AliCDBManager::Instance();
+  if(cdb->GetRun() < 0){
+    AliError("OCDB manager not properly initialized");
+    return;
+  }
+
+  AliTRDcalibDB *fCalib = AliTRDcalibDB::Instance();
+  AliTRDCalROC  *fCalVdriftROC = fCalib->GetVdriftROC(fDet);
+  const AliTRDCalDet  *fCalVdriftDet = fCalib->GetVdriftDet();
+
+  Int_t col = 70, row = 7;
+  AliTRDcluster **c = &fClusters[0];
+  if(fN){ 
+    Int_t ic = 0;
+    while (ic<AliTRDseed::knTimebins && !(*c)){ic++; c++;} 
+    if(*c){
+      col = (*c)->GetPadCol();
+      row = (*c)->GetPadRow();
+    }
+  }
+
+  Double_t vd = fCalVdriftDet->GetValue(fDet) * fCalVdriftROC->GetValue(col, row);
+  fExB   = fCalib->GetOmegaTau(vd, -0.1*AliTracker::GetBz());
 }
 
 //____________________________________________________________________
-void AliTRDseedV1::SetOwner(Bool_t own)
+void AliTRDseedV1::SetOwner()
 {
-       //AliInfo(Form("own [%s] fOwner[%s]", own?"YES":"NO", fOwner?"YES":"NO"));
-       
-       if(own){
-               for(int ic=0; ic<knTimebins; ic++){
-                       if(!fClusters[ic]) continue;
-                       fClusters[ic] = new AliTRDcluster(*fClusters[ic]);
-               }
-               fOwner = kTRUE;
-       } else {
-               if(fOwner){
-                       for(int ic=0; ic<knTimebins; ic++){
-                               if(!fClusters[ic]) continue;
-                               delete fClusters[ic];
-                               //fClusters[ic] = tracker->GetClusters(index) TODO
-                       }
-               }
-               fOwner = kFALSE;
-       }
+  //AliInfo(Form("own [%s] fOwner[%s]", own?"YES":"NO", fOwner?"YES":"NO"));
+  
+  if(TestBit(kOwner)) return;
+  for(int ic=0; ic<knTimebins; ic++){
+    if(!fClusters[ic]) continue;
+    fClusters[ic] = new AliTRDcluster(*fClusters[ic]);
+  }
+  SetBit(kOwner);
 }
 
 //____________________________________________________________________
-Bool_t AliTRDseedV1::AttachClustersIter(AliTRDstackLayer *layer
-                                       , Float_t quality
-                                       , Bool_t kZcorr
-                                       , AliTRDcluster *c)
+Bool_t AliTRDseedV1::AttachClustersIter(AliTRDtrackingChamber *chamber, Float_t quality, Bool_t kZcorr, AliTRDcluster *c)
 {
   //
   // Iterative process to register clusters to the seed.
   // In iteration 0 we try only one pad-row and if quality not
   // sufficient we try 2 pad-rows (about 5% of tracks cross 2 pad-rows)
   //
-       
-       if(!fRecoParam){
-               AliError("Seed can not be used without a valid RecoParam.");
-               return kFALSE;
-       }
-
-       //AliInfo(Form("TimeBins = %d TimeBinsRange = %d", fgTimeBins, fTimeBinsRange));
-
-       Float_t  tquality;
-       Double_t kroady = fRecoParam->GetRoad1y();
-       Double_t kroadz = fPadLength * .5 + 1.;
-       
-       // initialize configuration parameters
-       Float_t zcorr = kZcorr ? fTilt * (fZProb - fZref[0]) : 0.;
-       Int_t   niter = kZcorr ? 1 : 2;
-       
-       Double_t yexp, zexp;
-       Int_t ncl = 0;
-       // start seed update
-       for (Int_t iter = 0; iter < niter; iter++) {
-       //AliInfo(Form("iter = %i", iter));
-               ncl = 0;
-               for (Int_t iTime = 0; iTime < fgTimeBins; iTime++) {
-                       // define searching configuration
-                       Double_t dxlayer = layer[iTime].GetX() - fX0;
-                       if(c){
-                               zexp = c->GetZ();
-                               //Try 2 pad-rows in second iteration
-                               if (iter > 0) {
-                                       zexp = fZref[0] + fZref[1] * dxlayer - zcorr;
-                                       if (zexp > c->GetZ()) zexp = c->GetZ() + fPadLength*0.5;
-                                       if (zexp < c->GetZ()) zexp = c->GetZ() - fPadLength*0.5;
-                               }
-                       } else zexp = fZref[0];
-                       yexp  = fYref[0] + fYref[1] * dxlayer - zcorr;
-                       // get  cluster
-//                     printf("xexp = %3.3f ,yexp = %3.3f, zexp = %3.3f\n",layer[iTime].GetX(),yexp,zexp);
-//                     printf("layer[%i].GetNClusters() = %i\n", iTime, layer[iTime].GetNClusters());
-                       Int_t    index = layer[iTime].SearchNearestCluster(yexp, zexp, kroady, kroadz);
-
-//                     printf("%d[%d] x[%7.3f | %7.3f] y[%7.3f] z[%7.3f]\n", iTime, layer[iTime].GetNClusters(), dxlayer, layer[iTime].GetX(), yexp, zexp);
-//                     for(Int_t iclk = 0; iclk < layer[iTime].GetNClusters(); iclk++){
-//                             AliTRDcluster *testcl = layer[iTime].GetCluster(iclk);
-//                             printf("Cluster %i: %d x = %7.3f, y = %7.3f, z = %7.3f\n", iclk, testcl->GetLocalTimeBin(), testcl->GetX(), testcl->GetY(), testcl->GetZ());
-//                     }
-//                     printf("Index = %i\n",index);
-
-                       if (index < 0) continue;
-                       
-                       // Register cluster
-                       AliTRDcluster *cl = (AliTRDcluster*) layer[iTime].GetCluster(index);
-                       
-                       //printf("Cluster %i(0x%x): x = %3.3f, y = %3.3f, z = %3.3f\n", index, cl, cl->GetX(), cl->GetY(), cl->GetZ());
-
-                       Int_t globalIndex = layer[iTime].GetGlobalIndex(index);
-                       fIndexes[iTime]  = globalIndex;
-                       fClusters[iTime] = cl;
-                       fX[iTime]        = dxlayer;
-                       fY[iTime]        = cl->GetY();
-                       fZ[iTime]        = cl->GetZ();
-                       fdQ[iTime]       = cl->GetQ()/layer[iTime].GetdX();
-                       
-                       // Debugging
-                       ncl++;
-               }
-
-#ifdef SEED_DEBUG
-//             Int_t nclusters = 0;
-//             Float_t fD[iter] = 0.;
-//             for(int ic=0; ic<fgTimeBins+1; ic++){
-//                     AliTRDcluster *ci = fClusters[ic];
-//                     if(!ci) continue;
-//                     for(int jc=ic+1; jc<fgTimeBins+1; jc++){
-//                             AliTRDcluster *cj = fClusters[jc];
-//                             if(!cj) continue;
-//                             fD[iter] += TMath::Sqrt((ci->GetY()-cj->GetY())*(ci->GetY()-cj->GetY())+
-//                             (ci->GetZ()-cj->GetZ())*(ci->GetZ()-cj->GetZ()));
-//                             nclusters++;
-//                     }
-//             }
-//             if(nclusters) fD[iter] /= float(nclusters);
-#endif
-
-               AliTRDseed::Update();
-
-               if(IsOK()){
-                       tquality = GetQuality(kZcorr);
-                       if(tquality < quality) break;
-                       else quality = tquality;
-               }
-               kroadz *= 2.;
-       } // Loop: iter
-       if (!IsOK()) return kFALSE;
-
-       CookLabels();
-       UpdateUsed();
-       return kTRUE;   
+  // debug level 7
+  //
+  
+  if(!fReconstructor->GetRecoParam() ){
+    AliError("Seed can not be used without a valid RecoParam.");
+    return kFALSE;
+  }
+
+  AliTRDchamberTimeBin *layer = 0x0;
+  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker)>=7){
+    AliTRDtrackingChamber ch(*chamber);
+    ch.SetOwner(); 
+    TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    cstreamer << "AttachClustersIter"
+      << "chamber.="   << &ch
+      << "tracklet.="  << this
+      << "\n"; 
+  }
+
+  Float_t  tquality;
+  Double_t kroady = fReconstructor->GetRecoParam() ->GetRoad1y();
+  Double_t kroadz = fPadLength * .5 + 1.;
+  
+  // initialize configuration parameters
+  Float_t zcorr = kZcorr ? fTilt * (fZProb - fZref[0]) : 0.;
+  Int_t   niter = kZcorr ? 1 : 2;
+  
+  Double_t yexp, zexp;
+  Int_t ncl = 0;
+  // start seed update
+  for (Int_t iter = 0; iter < niter; iter++) {
+    ncl = 0;
+    for (Int_t iTime = 0; iTime < AliTRDtrackerV1::GetNTimeBins(); iTime++) {
+      if(!(layer = chamber->GetTB(iTime))) continue;
+      if(!Int_t(*layer)) continue;
+      
+      // define searching configuration
+      Double_t dxlayer = layer->GetX() - fX0;
+      if(c){
+        zexp = c->GetZ();
+        //Try 2 pad-rows in second iteration
+        if (iter > 0) {
+          zexp = fZref[0] + fZref[1] * dxlayer - zcorr;
+          if (zexp > c->GetZ()) zexp = c->GetZ() + fPadLength*0.5;
+          if (zexp < c->GetZ()) zexp = c->GetZ() - fPadLength*0.5;
+        }
+      } else zexp = fZref[0] + (kZcorr ? fZref[1] * dxlayer : 0.);
+      yexp  = fYref[0] + fYref[1] * dxlayer - zcorr;
+      
+      // Get and register cluster
+      Int_t    index = layer->SearchNearestCluster(yexp, zexp, kroady, kroadz);
+      if (index < 0) continue;
+      AliTRDcluster *cl = (*layer)[index];
+      
+      fIndexes[iTime]  = layer->GetGlobalIndex(index);
+      fClusters[iTime] = cl;
+      fY[iTime]        = cl->GetY();
+      fZ[iTime]        = cl->GetZ();
+      ncl++;
+    }
+    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker)>=7) AliInfo(Form("iter = %d ncl [%d] = %d", iter, fDet, ncl));
+    
+    if(ncl>1){ 
+      // calculate length of the time bin (calibration aware)
+      Int_t irp = 0; Float_t x[2]; Int_t tb[2];
+      for (Int_t iTime = 0; iTime < AliTRDtrackerV1::GetNTimeBins(); iTime++) {
+        if(!fClusters[iTime]) continue;
+        x[irp]  = fClusters[iTime]->GetX();
+        tb[irp] = iTime;
+        irp++;
+        if(irp==2) break;
+      } 
+      fdX = (x[1] - x[0]) / (tb[0] - tb[1]);
+  
+      // update X0 from the clusters (calibration/alignment aware)
+      for (Int_t iTime = 0; iTime < AliTRDtrackerV1::GetNTimeBins(); iTime++) {
+        if(!(layer = chamber->GetTB(iTime))) continue;
+        if(!layer->IsT0()) continue;
+        if(fClusters[iTime]){ 
+          fX0 = fClusters[iTime]->GetX();
+          break;
+        } else { // we have to infere the position of the anode wire from the other clusters
+          for (Int_t jTime = iTime+1; jTime < AliTRDtrackerV1::GetNTimeBins(); jTime++) {
+            if(!fClusters[jTime]) continue;
+            fX0 = fClusters[jTime]->GetX() + fdX * (jTime - iTime);
+            break;
+          }
+        }
+      }        
+      
+      // update YZ reference point
+      // TODO
+      
+      // update x reference positions (calibration/alignment aware)
+      for (Int_t iTime = 0; iTime < AliTRDtrackerV1::GetNTimeBins(); iTime++) {
+        if(!fClusters[iTime]) continue;
+        fX[iTime] = fX0 - fClusters[iTime]->GetX();
+      } 
+      
+      AliTRDseed::Update();
+    }
+    if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker)>=7) AliInfo(Form("iter = %d nclFit [%d] = %d", iter, fDet, fN2));
+    
+    if(IsOK()){
+      tquality = GetQuality(kZcorr);
+      if(tquality < quality) break;
+      else quality = tquality;
+    }
+    kroadz *= 2.;
+  } // Loop: iter
+  if (!IsOK()) return kFALSE;
+
+  if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker)>=1) CookLabels();
+
+  // set ExB angle
+  SetExB();
+  UpdateUsed();
+  return kTRUE;        
 }
 
 //____________________________________________________________________
-Bool_t AliTRDseedV1::AttachClusters(AliTRDstackLayer *layer
-                                       ,Bool_t kZcorr)
+Bool_t AliTRDseedV1::AttachClusters(AliTRDtrackingChamber *chamber, Bool_t tilt)
 {
   //
   // Projective algorithm to attach clusters to seeding tracklets
@@ -447,133 +656,242 @@ Bool_t  AliTRDseedV1::AttachClusters(AliTRDstackLayer *layer
   // 5. purge clusters
   // 6. fit tracklet
   //   
+  Bool_t kPRINT = kFALSE;
+  if(!fReconstructor->GetRecoParam() ){
+    AliError("Seed can not be used without a valid RecoParam.");
+    return kFALSE;
+  }
+  // Initialize reco params for this tracklet
+  // 1. first time bin in the drift region
+  Int_t t0 = 4;
+  Int_t kClmin = Int_t(fReconstructor->GetRecoParam() ->GetFindableClusters()*AliTRDtrackerV1::GetNTimeBins());
+
+  Double_t syRef  = TMath::Sqrt(fRefCov[0]);
+  //define roads
+  Double_t kroady = 1.; 
+  //fReconstructor->GetRecoParam() ->GetRoad1y();
+  Double_t kroadz = fPadLength * 1.5 + 1.;
+  if(kPRINT) printf("AttachClusters() sy[%f] road[%f]\n", syRef, kroady);
+
+  // working variables
+  const Int_t kNrows = 16;
+  AliTRDcluster *clst[kNrows][knTimebins];
+  Double_t cond[4], dx, dy, yt, zt,
+    yres[kNrows][knTimebins];
+  Int_t idxs[kNrows][knTimebins], ncl[kNrows], ncls = 0;
+  memset(ncl, 0, kNrows*sizeof(Int_t));
+  memset(clst, 0, kNrows*knTimebins*sizeof(AliTRDcluster*));
+
+  // Do cluster projection
+  AliTRDcluster *c = 0x0;
+  AliTRDchamberTimeBin *layer = 0x0;
+  Bool_t kBUFFER = kFALSE;
+  for (Int_t it = 0; it < AliTRDtrackerV1::GetNTimeBins(); it++) {
+    if(!(layer = chamber->GetTB(it))) continue;
+    if(!Int_t(*layer)) continue;
+    
+    dx   = fX0 - layer->GetX();
+    yt = fYref[0] - fYref[1] * dx;
+    zt = fZref[0] - fZref[1] * dx;
+    if(kPRINT) printf("\t%2d dx[%f] yt[%f] zt[%f]\n", it, dx, yt, zt);
+
+    // select clusters on a 5 sigmaKalman level
+    cond[0] = yt; cond[2] = kroady;
+    cond[1] = zt; cond[3] = kroadz;
+    Int_t n=0, idx[6];
+    layer->GetClusters(cond, idx, n, 6);
+    for(Int_t ic = n; ic--;){
+      c  = (*layer)[idx[ic]];
+      dy = yt - c->GetY();
+      dy += tilt ? fTilt * (c->GetZ() - zt) : 0.;
+      // select clusters on a 3 sigmaKalman level
+/*      if(tilt && TMath::Abs(dy) > 3.*syRef){ 
+        printf("too large !!!\n");
+        continue;
+      }*/
+      Int_t r = c->GetPadRow();
+      if(kPRINT) printf("\t\t%d dy[%f] yc[%f] r[%d]\n", ic, TMath::Abs(dy), c->GetY(), r);
+      clst[r][ncl[r]] = c;
+      idxs[r][ncl[r]] = idx[ic];
+      yres[r][ncl[r]] = dy;
+      ncl[r]++; ncls++;
+
+      if(ncl[r] >= knTimebins) {
+        AliWarning(Form("Cluster candidates reached limit %d. Some may be lost.", knTimebins));
+        kBUFFER = kTRUE;
+        break;
+      }
+    }
+    if(kBUFFER) break;
+  }
+  if(kPRINT) printf("Found %d clusters\n", ncls);
+  if(ncls<kClmin) return kFALSE;
+  // analyze each row individualy
+  Double_t mean, syDis;
+  Int_t nrow[] = {0, 0, 0}, nr = 0, lr=-1;
+  for(Int_t ir=kNrows; ir--;){
+    if(!(ncl[ir])) continue;
+    if(lr>0 && lr-ir != 1){
+      if(kPRINT) printf("W - gap in rows attached !!\n"); 
+    }
+    if(kPRINT) printf("\tir[%d] lr[%d] n[%d]\n", ir, lr, ncl[ir]);
+    // Evaluate truncated mean on the y direction
+    if(ncl[ir] > 3) AliMathBase::EvaluateUni(ncl[ir], yres[ir], mean, syDis, Int_t(ncl[ir]*.8));
+    else {
+      mean = 0.; syDis = 0.;
+    } 
+
+    // TODO check mean and sigma agains cluster resolution !!
+    if(kPRINT) printf("\tr[%2d] m[%f %5.3fsigma] s[%f]\n", ir, mean, TMath::Abs(mean/syRef), syDis);
+    // select clusters on a 3 sigmaDistr level
+    Bool_t kFOUND = kFALSE;
+    for(Int_t ic = ncl[ir]; ic--;){
+      if(yres[ir][ic] - mean > 3. * syDis){ 
+        clst[ir][ic] = 0x0; continue;
+      }
+      nrow[nr]++; kFOUND = kTRUE;
+    }
+    // exit loop
+    if(kFOUND) nr++; 
+    lr = ir; if(nr>=3) break;
+  }
+  if(kPRINT) printf("lr[%d] nr[%d] nrow[0]=%d nrow[1]=%d nrow[2]=%d\n", lr, nr, nrow[0], nrow[1], nrow[2]);
+
+  // classify cluster rows
+  Int_t row = -1;
+  switch(nr){
+  case 1:
+    row = lr;
+    break;
+  case 2:
+    SetBit(kRowCross, kTRUE); // mark pad row crossing
+    if(nrow[0] > nrow[1]){ row = lr+1; lr = -1;}
+    else{ 
+      row = lr; lr = 1;
+      nrow[2] = nrow[1];
+      nrow[1] = nrow[0];
+      nrow[0] = nrow[2];
+    }
+    break;
+  case 3:
+    SetBit(kRowCross, kTRUE); // mark pad row crossing
+    break;
+  }
+  if(kPRINT) printf("\trow[%d] n[%d]\n\n", row, nrow[0]);
+  if(row<0) return kFALSE;
+
+  // Select and store clusters 
+  // We should consider here :
+  //  1. How far is the chamber boundary
+  //  2. How big is the mean
+  fN2 = 0;
+  for (Int_t ir = 0; ir < nr; ir++) {
+    Int_t jr = row + ir*lr; 
+    if(kPRINT) printf("\tattach %d clusters for row %d\n", ncl[jr], jr);
+    for (Int_t ic = 0; ic < ncl[jr]; ic++) {
+      if(!(c = clst[jr][ic])) continue;
+      Int_t it = c->GetPadTime();
+      // TODO proper indexing of clusters !!
+      fIndexes[it+35*ir]  = chamber->GetTB(it)->GetGlobalIndex(idxs[jr][ic]);
+      fClusters[it+35*ir] = c;
+  
+      //printf("\tid[%2d] it[%d] idx[%d]\n", ic, it, fIndexes[it]);
+  
+      fN2++;
+    }
+  }  
 
-       if(!fRecoParam){
-               AliError("Seed can not be used without a valid RecoParam.");
-               return kFALSE;
-       }
-
-       const Int_t kClusterCandidates = 2 * knTimebins;
-       
-       //define roads
-       Double_t kroady = fRecoParam->GetRoad1y();
-       Double_t kroadz = fPadLength * 1.5 + 1.;
-       // correction to y for the tilting angle
-       Float_t zcorr = kZcorr ? fTilt * (fZProb - fZref[0]) : 0.;
-
-       // working variables
-       AliTRDcluster *clusters[kClusterCandidates];
-       Double_t cond[4], yexp[knTimebins], zexp[knTimebins],
-               yres[kClusterCandidates], zres[kClusterCandidates];
-       Int_t ncl, *index = 0x0, tboundary[knTimebins];
-       
-       // Do cluster projection
-       Int_t nYclusters = 0; Bool_t kEXIT = kFALSE;
-       for (Int_t iTime = 0; iTime < fgTimeBins; iTime++) {
-               fX[iTime] = layer[iTime].GetX() - fX0;
-               zexp[iTime] = fZref[0] + fZref[1] * fX[iTime];
-               yexp[iTime] = fYref[0] + fYref[1] * fX[iTime] - zcorr;
-               
-               // build condition and process clusters
-               cond[0] = yexp[iTime] - kroady; cond[1] = yexp[iTime] + kroady;
-               cond[2] = zexp[iTime] - kroadz; cond[3] = zexp[iTime] + kroadz;
-               layer[iTime].GetClusters(cond, index, ncl);
-               for(Int_t ic = 0; ic<ncl; ic++){
-                       AliTRDcluster *c = layer[iTime].GetCluster(index[ic]);
-                       clusters[nYclusters] = c;
-                       yres[nYclusters++] = c->GetY() - yexp[iTime];
-                       if(nYclusters >= kClusterCandidates) {
-                               AliWarning(Form("Cluster candidates reached limit %d. Some may be lost.", kClusterCandidates));
-                               kEXIT = kTRUE;
-                               break;
-                       }
-               }
-               tboundary[iTime] = nYclusters;
-               if(kEXIT) break;
-       }
-       
-       // Evaluate truncated mean on the y direction
-       Double_t mean, sigma;
-       AliMathBase::EvaluateUni(nYclusters, yres, mean, sigma, Int_t(nYclusters*.8)-2);
-       //purge cluster candidates
-       Int_t nZclusters = 0;
-       for(Int_t ic = 0; ic<nYclusters; ic++){
-               if(yres[ic] - mean > 4. * sigma){
-                       clusters[ic] = 0x0;
-                       continue;
-               }
-               zres[nZclusters++] = clusters[ic]->GetZ() - zexp[clusters[ic]->GetLocalTimeBin()];
-       }
-       
-       // Evaluate truncated mean on the z direction
-       AliMathBase::EvaluateUni(nZclusters, zres, mean, sigma, Int_t(nZclusters*.8)-2);
-       //purge cluster candidates
-       for(Int_t ic = 0; ic<nZclusters; ic++){
-               if(zres[ic] - mean > 4. * sigma){
-                       clusters[ic] = 0x0;
-                       continue;
-               }
-       }
-
-       
-       // Select only one cluster/TimeBin
-       Int_t lastCluster = 0;
-       fN2 = 0;
-       for (Int_t iTime = 0; iTime < fgTimeBins; iTime++) {
-               ncl = tboundary[iTime] - lastCluster;
-               if(!ncl) continue;
-               AliTRDcluster *c = 0x0;
-               if(ncl == 1){
-                       c = clusters[lastCluster];
-               } else if(ncl > 1){
-                       Float_t dold = 9999.; Int_t iptr = lastCluster;
-                       for(int ic=lastCluster; ic<tboundary[iTime]; ic++){
-                               if(!clusters[ic]) continue;
-                               Float_t y = yexp[iTime] - clusters[ic]->GetY();
-                               Float_t z = zexp[iTime] - clusters[ic]->GetZ();
-                               Float_t d = y * y + z * z;
-                               if(d > dold) continue;
-                               dold = d;
-                               iptr = ic;
-                       }
-                       c = clusters[iptr];
-               }
-               //Int_t GlobalIndex = layer[iTime].GetGlobalIndex(index);
-               //fIndexes[iTime]  = GlobalIndex;
-               fClusters[iTime] = c;
-               fY[iTime]        = c->GetY();
-               fZ[iTime]        = c->GetZ();
-               fdQ[iTime]       = c->GetQ()/layer[iTime].GetdX();
-               lastCluster      = tboundary[iTime];
-               fN2++;
-       }
-       
-       // number of minimum numbers of clusters expected for the tracklet
-       Int_t kClmin = Int_t(fRecoParam->GetFindableClusters()*fgTimeBins);
+  // number of minimum numbers of clusters expected for the tracklet
   if (fN2 < kClmin){
-               AliWarning(Form("Not enough clusters to fit the tracklet %d [%d].", fN2, kClmin));
+    AliWarning(Form("Not enough clusters to fit the tracklet %d [%d].", fN2, kClmin));
     fN2 = 0;
     return kFALSE;
   }
 
-       // update used clusters
-       fNUsed = 0;
-       for (Int_t iTime = 0; iTime < fgTimeBins; iTime++) {
-               if(!fClusters[iTime]) continue;
-               if((fClusters[iTime]->IsUsed())) fNUsed++;
-       }
-
+  // update used clusters and select
+  fNUsed = 0;
+  for (Int_t it = 0; it < AliTRDtrackerV1::GetNTimeBins(); it++) {
+    if(fClusters[it] && fClusters[it]->IsUsed()) fNUsed++;
+    if(fClusters[it+35] && fClusters[it+35]->IsUsed()) fNUsed++;
+  }
   if (fN2-fNUsed < kClmin){
-               AliWarning(Form("Too many clusters already in use %d (from %d).", fNUsed, fN2));
+    //AliWarning(Form("Too many clusters already in use %d (from %d).", fNUsed, fN2));
     fN2 = 0;
     return kFALSE;
   }
-       
-       return kTRUE;
+
+  // set the Lorentz angle for this tracklet  
+  SetExB();
+
+  // calculate dx for time bins in the drift region (calibration aware)
+  Int_t irp = 0; Float_t x[2]; Int_t tb[2];
+  for (Int_t it = t0; it < AliTRDtrackerV1::GetNTimeBins(); it++) {
+    if(!fClusters[it]) continue;
+    x[irp]  = fClusters[it]->GetX();
+    tb[irp] = it;
+    irp++;
+    if(irp==2) break;
+  } 
+  fdX = (x[1] - x[0]) / (tb[0] - tb[1]);
+
+  // update X0 from the clusters (calibration/alignment aware) TODO remove dependence on x0 !!
+  for (Int_t it = 0; it < AliTRDtrackerV1::GetNTimeBins(); it++) {
+    if(!(layer = chamber->GetTB(it))) continue;
+    if(!layer->IsT0()) continue;
+    if(fClusters[it]){ 
+      fX0 = fClusters[it]->GetX();
+      break;
+    } else { // we have to infere the position of the anode wire from the other clusters
+      for (Int_t jt = it+1; jt < AliTRDtrackerV1::GetNTimeBins(); jt++) {
+        if(!fClusters[jt]) continue;
+        fX0 = fClusters[jt]->GetX() + fdX * (jt - it);
+        break;
+      }
+    }
+  }    
+
+  return kTRUE;
+}
+
+//____________________________________________________________
+void AliTRDseedV1::Bootstrap(const AliTRDReconstructor *rec)
+{
+//   Fill in all derived information. It has to be called after recovery from file or HLT.
+//   The primitive data are
+//   - list of clusters
+//   - detector (as the detector will be removed from clusters)
+//   - position of anode wire (fX0) - temporary
+//   - track reference position and direction
+//   - momentum of the track
+//   - time bin length [cm]
+// 
+//   A.Bercuci <A.Bercuci@gsi.de> Oct 30th 2008
+//
+  fReconstructor = rec;
+  AliTRDgeometry g;
+  AliTRDpadPlane *pp = g.GetPadPlane(fDet);
+  fTilt      = TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle());
+  fPadLength = pp->GetLengthIPad();
+  fSnp = fYref[1]/TMath::Sqrt(1+fYref[1]*fYref[1]);
+  fTgl = fZref[1];
+  fN = 0; fN2 = 0; fMPads = 0.;
+  AliTRDcluster **cit = &fClusters[0];
+  for(Int_t ic = knTimebins; ic--; cit++){
+    if(!(*cit)) return;
+    fN++; fN2++;
+    fX[ic] = (*cit)->GetX() - fX0;
+    fY[ic] = (*cit)->GetY();
+    fZ[ic] = (*cit)->GetZ();
+  }
+  Update(); // Fit();
+  CookLabels();
+  GetProbability();
 }
 
+
 //____________________________________________________________________
-Bool_t AliTRDseedV1::Fit()
+Bool_t AliTRDseedV1::Fit(Bool_t tilt, Int_t errors)
 {
   //
   // Linear fit of the tracklet
@@ -589,288 +907,290 @@ Bool_t AliTRDseedV1::Fit()
   // 3. Do a Least Square Fit to the data
   //
 
-       //Float_t  sigmaexp  = 0.05 + TMath::Abs(fYref[1] * 0.25); // Expected r.m.s in y direction
-  Float_t  ycrosscor = fPadLength * fTilt * 0.5; // Y correction for crossing
-  Float_t  anglecor = fTilt * fZref[1];  // Correction to the angle
-
-       // calculate residuals
-       Float_t yres[knTimebins]; // y (r-phi) residuals
-       Int_t zint[knTimebins],   // Histograming of the z coordinate
-             zout[2*knTimebins];//
-       
-       fN = 0;
-       for (Int_t iTime = 0; iTime < fTimeBinsRange; iTime++) {
-    if (!fClusters[iTime]) continue;
-    yres[iTime] = fY[iTime] - fYref[0] - (fYref[1] + anglecor) * fX[iTime];
-               zint[fN] = Int_t(fZ[iTime]);
-               fN++;
-       }
-
-       // calculate pad row boundary crosses
-       Int_t kClmin = Int_t(fRecoParam->GetFindableClusters()*fTimeBinsRange);
-       Int_t nz = AliMathBase::Freq(fN, zint, zout, kFALSE);
-  fZProb   = zout[0];
-  if(nz <= 1) zout[3] = 0;
-  if(zout[1] + zout[3] < kClmin) {
-               AliWarning(Form("Not enough clusters to fit the cross boundary tracklet %d [%d].", zout[1]+zout[3], kClmin));
-               return kFALSE;
-       }
-  // Z distance bigger than pad - length
-  if (TMath::Abs(zout[0]-zout[2]) > fPadLength) zout[3]=0;
-
-  Double_t sumw   = 0., 
-               sumwx  = 0.,
-               sumwx2 = 0.,
-               sumwy  = 0.,
-               sumwxy = 0.,
-               sumwz  = 0.,
-               sumwxz = 0.;
-       Int_t npads;
-  fMPads = 0;
-       fMeanz = 0.;
-       // we will use only the clusters which are in the detector range
-       for(int iTime=0; iTime<fTimeBinsRange; iTime++){
-    fUsable[iTime] = kFALSE;
-    if (!fClusters[iTime]) continue;
-               npads = fClusters[iTime]->GetNPads();
-
-               fUsable[iTime] = kTRUE;
-    fN2++;
-    fMPads += npads;
-    Float_t weight = 1.0;
-    if(npads > 5) weight = 0.2;
-    else if(npads > 4) weight = 0.5;
-    sumw   += weight; 
-    sumwx  += fX[iTime] * weight;
-    sumwx2 += fX[iTime] * fX[iTime] * weight;
-    sumwy  += weight * yres[iTime];
-    sumwxy += weight * yres[iTime] * fX[iTime];
-    sumwz  += weight * fZ[iTime];    
-    sumwxz += weight * fZ[iTime] * fX[iTime];
-       }
-  if (fN2 < kClmin){
-               AliWarning(Form("Not enough clusters to fit the tracklet %d [%d].", fN2, kClmin));
-    fN2 = 0;
-    return kFALSE;
+  const Int_t kClmin = 8;
+
+
+  // cluster error parametrization parameters 
+  // 1. sy total charge
+  const Float_t sq0inv = 0.019962; // [1/q0]
+  const Float_t sqb    = 1.0281564;    //[cm]
+  // 2. sy for the PRF
+  const Float_t scy[AliTRDgeometry::kNlayer][4] = {
+    {2.827e-02, 9.600e-04, 4.296e-01, 2.271e-02},
+    {2.952e-02,-2.198e-04, 4.146e-01, 2.339e-02},
+    {3.090e-02, 1.514e-03, 4.020e-01, 2.402e-02},
+    {3.260e-02,-2.037e-03, 3.946e-01, 2.509e-02},
+    {3.439e-02,-3.601e-04, 3.883e-01, 2.623e-02},
+    {3.510e-02, 2.066e-03, 3.651e-01, 2.588e-02},
+  };
+  // 3. sy parallel to the track
+  const Float_t sy0 =  2.649e-02; // [cm]
+  const Float_t sya = -8.864e-04; // [cm]
+  const Float_t syb = -2.435e-01; // [cm]
+
+  // 4. sx parallel to the track
+  const Float_t sxgc = 5.427e-02;
+  const Float_t sxgm = 7.783e-01;
+  const Float_t sxgs = 2.743e-01;
+  const Float_t sxe0 =-2.065e+00;
+  const Float_t sxe1 =-2.978e-02;
+
+  // 5. sx perpendicular to the track
+//   const Float_t sxd0 = 1.881e-02;
+//   const Float_t sxd1 =-4.101e-01;
+//   const Float_t sxd2 = 1.572e+00;
+
+  // get track direction
+  Double_t y0   = fYref[0];
+  Double_t dydx = fYref[1]; 
+  Double_t z0   = fZref[0];
+  Double_t dzdx = fZref[1];
+  Double_t yt, zt;
+
+  const Int_t kNtb = AliTRDtrackerV1::GetNTimeBins();
+  //AliTRDtrackerV1::AliTRDLeastSquare fitterZ;
+  TLinearFitter  fitterY(1, "pol1");
+  // convertion factor from square to gauss distribution for sigma
+  //Double_t convert = 1./TMath::Sqrt(12.);
+  
+  // book cluster information
+  Double_t q, xc[knTimebins], yc[knTimebins], zc[knTimebins], sy[knTimebins]/*, sz[knTimebins]*/;
+//   Int_t zRow[knTimebins];
+  
+  Int_t ily = AliTRDgeometry::GetLayer(fDet);
+  fN = 0; //fXref = 0.; Double_t ssx = 0.;
+  AliTRDcluster *c=0x0, **jc = &fClusters[0];
+  for (Int_t ic=0; ic<kNtb; ic++, ++jc) {
+    //zRow[ic] = -1;
+    xc[ic]  = -1.;
+    yc[ic]  = 999.;
+    zc[ic]  = 999.;
+    sy[ic]  = 0.;
+    //sz[ic]  = 0.;
+    if(!(c = (*jc))) continue;
+    if(!c->IsInChamber()) continue;
+
+    Float_t w = 1.;
+    if(c->GetNPads()>4) w = .5;
+    if(c->GetNPads()>5) w = .2;
+
+    //zRow[fN] = c->GetPadRow();
+    // correct cluster position for PRF and v drift
+    Double_t x, y; GetClusterXY(c, x, y);
+    xc[fN]   = fX0 - x;
+    yc[fN]   = y;
+    zc[fN]   = c->GetZ();
+
+    // extrapolated y value for the track
+    yt = y0 - xc[fN]*dydx; 
+    // extrapolated z value for the track
+    zt = z0 - xc[fN]*dzdx; 
+    // tilt correction
+    if(tilt) yc[fN] -= fTilt*(zc[fN] - zt); 
+
+    // ELABORATE CLUSTER ERROR
+    // TODO to be moved to AliTRDcluster
+    q = TMath::Abs(c->GetQ());
+    Double_t tgg = (dydx-fExB)/(1.+dydx*fExB); tgg *= tgg;
+    // basic y error (|| to track).
+    sy[fN]  = xc[fN] < AliTRDgeometry::CamHght() ? 2. : sy0 + sya*TMath::Exp(1./(xc[fN]+syb));
+    //printf("cluster[%d]\n\tsy[0] = %5.3e [um]\n", fN,  sy[fN]*1.e4);
+    // y error due to total charge
+    sy[fN] += sqb*(1./q - sq0inv);
+    //printf("\tsy[1] = %5.3e [um]\n", sy[fN]*1.e4);
+    // y error due to PRF
+    sy[fN] += scy[ily][0]*TMath::Gaus(c->GetCenter(), scy[ily][1], scy[ily][2]) - scy[ily][3];
+    //printf("\tsy[2] = %5.3e [um]\n", sy[fN]*1.e4);
+
+    sy[fN] *= sy[fN];
+
+    // ADD ERROR ON x
+    // error of drift length parallel to the track
+    Double_t sx = sxgc*TMath::Gaus(xc[fN], sxgm, sxgs) + TMath::Exp(sxe0+sxe1*xc[fN]); // [cm]
+    //printf("\tsx[0] = %5.3e [um]\n", sx*1.e4);
+    // error of drift length perpendicular to the track
+    //sx += sxd0 + sxd1*d + sxd2*d*d;
+    sx *= sx; // square sx
+    // update xref
+    //fXref += xc[fN]/sx; ssx+=1./sx;
+
+    // add error from ExB 
+    if(errors>0) sy[fN] += fExB*fExB*sx;
+    //printf("\tsy[3] = %5.3e [um^2]\n", sy[fN]*1.e8);
+
+    // global radial error due to misalignment/miscalibration
+    Double_t sx0  = 0.; sx0 *= sx0;
+    // add sx contribution to sy due to track angle
+    if(errors>1) sy[fN] += tgg*(sx+sx0);
+    // TODO we should add tilt pad correction here
+    //printf("\tsy[4] = %5.3e [um^2]\n", sy[fN]*1.e8);
+    c->SetSigmaY2(sy[fN]);
+
+    sy[fN]  = TMath::Sqrt(sy[fN]);
+    fitterY.AddPoint(&xc[fN], yc[fN]/*-yt*/, sy[fN]);
+    fN++;
   }
-  fMeanz = sumwz / sumw;
-       fNChange = 0;
-
-       // Tracklet on boundary
-  Float_t correction = 0;
-  if (fNChange > 0) {
-    if (fMeanz < fZProb) correction =  ycrosscor;
-    if (fMeanz > fZProb) correction = -ycrosscor;
+  // to few clusters
+  if (fN < kClmin) return kFALSE; 
+
+  // fit XY
+  fitterY.Eval();
+  fYfit[0] = fitterY.GetParameter(0);
+  fYfit[1] = -fitterY.GetParameter(1);
+  // store covariance
+  Double_t *p = fitterY.GetCovarianceMatrix();
+  fCov[0] = p[0]; // variance of y0
+  fCov[1] = p[1]; // covariance of y0, dydx
+  fCov[2] = p[3]; // variance of dydx
+  // the ref radial position is set at the minimum of 
+  // the y variance of the tracklet
+  fXref = -fCov[1]/fCov[2]; //fXref = fX0 - fXref;
+
+  // fit XZ
+  if(IsRowCross()){ 
+    // TODO pad row cross position estimation !!!
+    //AliInfo(Form("Padrow cross in detector %d", fDet));
+    fZfit[0] = .5*(zc[0]+zc[fN-1]); fZfit[1] = 0.;
+  } else {
+    fZfit[0] = zc[0]; fZfit[1] = 0.;
   }
 
-  Double_t det = sumw * sumwx2 - sumwx * sumwx;
-  fYfitR[0]    = (sumwx2 * sumwy  - sumwx * sumwxy) / det;
-  fYfitR[1]    = (sumw   * sumwxy - sumwx * sumwy)  / det;
-  
-  fSigmaY2 = 0;
-  for (Int_t i = 0; i < fTimeBinsRange+1; i++) {
-    if (!fUsable[i]) continue;
-    Float_t delta = yres[i] - fYfitR[0] - fYfitR[1] * fX[i];
-    fSigmaY2 += delta*delta;
-  }
-  fSigmaY2 = TMath::Sqrt(fSigmaY2 / Float_t(fN2-2));
-  
-  fZfitR[0]  = (sumwx2 * sumwz  - sumwx * sumwxz) / det;
-  fZfitR[1]  = (sumw   * sumwxz - sumwx * sumwz)  / det;
-  fZfit[0]   = (sumwx2 * sumwz  - sumwx * sumwxz) / det;
-  fZfit[1]   = (sumw   * sumwxz - sumwx * sumwz)  / det;
-  fYfitR[0] += fYref[0] + correction;
-  fYfitR[1] += fYref[1];
-  fYfit[0]   = fYfitR[0];
-  fYfit[1]   = fYfitR[1];
-
-       return kTRUE;
+
+//   // determine z offset of the fit
+//   Float_t zslope = 0.;
+//   Int_t nchanges = 0, nCross = 0;
+//   if(nz==2){ // tracklet is crossing pad row
+//     // Find the break time allowing one chage on pad-rows
+//     // with maximal number of accepted clusters
+//     Int_t padRef = zRow[0];
+//     for (Int_t ic=1; ic<fN; ic++) {
+//       if(zRow[ic] == padRef) continue;
+//       
+//       // debug
+//       if(zRow[ic-1] == zRow[ic]){
+//         printf("ERROR in pad row change!!!\n");
+//       }
+//     
+//       // evaluate parameters of the crossing point
+//       Float_t sx = (xc[ic-1] - xc[ic])*convert;
+//       fCross[0] = .5 * (xc[ic-1] + xc[ic]);
+//       fCross[2] = .5 * (zc[ic-1] + zc[ic]);
+//       fCross[3] = TMath::Max(dzdx * sx, .01);
+//       zslope    = zc[ic-1] > zc[ic] ? 1. : -1.;
+//       padRef    = zRow[ic];
+//       nCross    = ic;
+//       nchanges++;
+//     }
+//   }
+// 
+//   // condition on nCross and reset nchanges TODO
+// 
+//   if(nchanges==1){
+//     if(dzdx * zslope < 0.){
+//       AliInfo("Tracklet-Track mismatch in dzdx. TODO.");
+//     }
+// 
+// 
+//     //zc[nc] = fitterZ.GetFunctionParameter(0); 
+//     fCross[1] = fYfit[0] - fCross[0] * fYfit[1];
+//     fCross[0] = fX0 - fCross[0];
+//   }
+
+  UpdateUsed();
+  return kTRUE;
 }
 
-//_____________________________________________________________________________
-Float_t AliTRDseedV1::FitRiemanTilt(AliTRDseedV1 *cseed, Bool_t terror)
+
+//___________________________________________________________________
+void AliTRDseedV1::Print(Option_t *o) const
 {
   //
-  // Fit the Rieman tilt
+  // Printing the seedstatus
   //
 
-  // Fitting with tilting pads - kz not fixed
-       AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
-       Int_t nTimeBins = cal->GetNumberOfTimeBins();
-  TLinearFitter fitterT2(4,"hyp4");  
-  fitterT2.StoreData(kTRUE);
-  Float_t xref2 = (cseed[2].fX0 + cseed[3].fX0) * 0.5; // Reference x0 for z
-  
-  Int_t npointsT = 0;
-  fitterT2.ClearPoints();
-
-  for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
-//             printf("\nLayer %d\n", iLayer);
-//     cseed[iLayer].Print();
-               if (!cseed[iLayer].IsOK()) continue;
-    Double_t tilt = cseed[iLayer].fTilt;
-
-    for (Int_t itime = 0; itime < nTimeBins+1; itime++) {
-//                     printf("\ttime %d\n", itime);
-      if (!cseed[iLayer].fUsable[itime]) continue;
-      // x relative to the midle chamber
-      Double_t x = cseed[iLayer].fX[itime] + cseed[iLayer].fX0 - xref2;  
-      Double_t y = cseed[iLayer].fY[itime];
-      Double_t z = cseed[iLayer].fZ[itime];
-
-      //
-      // Tilted rieman
-      //
-      Double_t uvt[6];
-      Double_t x2 = cseed[iLayer].fX[itime] + cseed[iLayer].fX0;      // Global x
-      Double_t t  = 1.0 / (x2*x2 + y*y);
-      uvt[1]  = t;
-      uvt[0]  = 2.0 * x2   * uvt[1];
-      uvt[2]  = 2.0 * tilt * uvt[1];
-      uvt[3]  = 2.0 * tilt *uvt[1] * x;              
-      uvt[4]  = 2.0 * (y + tilt * z) * uvt[1];
-      
-      Double_t error = 2.0 * uvt[1];
-      if (terror) {
-        error *= cseed[iLayer].fSigmaY;
-      }
-      else {
-        error *= 0.2; //Default error
-      }
-//                     printf("\tadd point :\n");
-//                     for(int i=0; i<5; i++) printf("%f ", uvt[i]);
-//                     printf("\n");
-      fitterT2.AddPoint(uvt,uvt[4],error);
-      npointsT++;
+  AliInfo(Form("Det[%3d] Tilt[%+6.2f] Pad[%5.2f]", fDet, fTilt, fPadLength));
+  AliInfo(Form("Nattach[%2d] Nfit[%2d] Nuse[%2d] pads[%f]", fN, fN2, fNUsed, fMPads));
+  AliInfo(Form("x[%7.2f] y[%7.2f] z[%7.2f] dydx[%5.2f] dzdx[%5.2f]", fX0, fYfit[0], fZfit[0], fYfit[1], fZfit[1]));
+  AliInfo(Form("Ref        y[%7.2f] z[%7.2f] dydx[%5.2f] dzdx[%5.2f]", fYref[0], fZref[0], fYref[1], fZref[1]))
 
-    }
 
-  }
-  fitterT2.Eval();
-  Double_t rpolz0 = fitterT2.GetParameter(3);
-  Double_t rpolz1 = fitterT2.GetParameter(4);      
+  if(strcmp(o, "a")!=0) return;
 
-  //
-  // Linear fitter  - not possible to make boundaries
-  // non accept non possible z and dzdx combination
-  //       
-  Bool_t acceptablez = kTRUE;
-  for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
-    if (cseed[iLayer].IsOK()) {
-      Double_t zT2 = rpolz0 + rpolz1 * (cseed[iLayer].fX0 - xref2);
-      if (TMath::Abs(cseed[iLayer].fZProb - zT2) > cseed[iLayer].fPadLength * 0.5 + 1.0) {
-       acceptablez = kFALSE;
-      }
-    }
-  }
-  if (!acceptablez) {
-    Double_t zmf  = cseed[2].fZref[0] + cseed[2].fZref[1] * (xref2 - cseed[2].fX0);
-    Double_t dzmf = (cseed[2].fZref[1] + cseed[3].fZref[1]) * 0.5;
-    fitterT2.FixParameter(3,zmf);
-    fitterT2.FixParameter(4,dzmf);
-    fitterT2.Eval();
-    fitterT2.ReleaseParameter(3);
-    fitterT2.ReleaseParameter(4);
-    rpolz0 = fitterT2.GetParameter(3);
-    rpolz1 = fitterT2.GetParameter(4);
+  AliTRDcluster* const* jc = &fClusters[0];
+  for(int ic=0; ic<AliTRDtrackerV1::GetNTimeBins(); ic++, jc++) {
+    if(!(*jc)) continue;
+    (*jc)->Print(o);
   }
-  
-  Double_t chi2TR = fitterT2.GetChisquare() / Float_t(npointsT);  
-  Double_t params[3];
-  params[0] =  fitterT2.GetParameter(0);
-  params[1] =  fitterT2.GetParameter(1);
-  params[2] =  fitterT2.GetParameter(2);           
-  Double_t curvature =  1.0 + params[1] * params[1] - params[2] * params[0];
-
-  for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
-
-    Double_t  x  = cseed[iLayer].fX0;
-    Double_t  y  = 0;
-    Double_t  dy = 0;
-    Double_t  z  = 0;
-    Double_t  dz = 0;
-
-    // y
-    Double_t res2 = (x * params[0] + params[1]);
-    res2 *= res2;
-    res2  = 1.0 - params[2]*params[0] + params[1]*params[1] - res2;
-    if (res2 >= 0) {
-      res2 = TMath::Sqrt(res2);
-      y    = (1.0 - res2) / params[0];
-    }
-
-    //dy
-    Double_t x0 = -params[1] / params[0];
-    if (-params[2]*params[0] + params[1]*params[1] + 1 > 0) {
-      Double_t rm1 = params[0] / TMath::Sqrt(-params[2]*params[0] + params[1]*params[1] + 1); 
-      if (1.0/(rm1*rm1) - (x-x0) * (x-x0) > 0.0) {
-       Double_t res = (x - x0) / TMath::Sqrt(1.0 / (rm1*rm1) - (x-x0)*(x-x0));
-       if (params[0] < 0) res *= -1.0;
-       dy = res;
-      }
-    }
-    z  = rpolz0 + rpolz1 * (x - xref2);
-    dz = rpolz1;
-    cseed[iLayer].fYref[0] = y;
-    cseed[iLayer].fYref[1] = dy;
-    cseed[iLayer].fZref[0] = z;
-    cseed[iLayer].fZref[1] = dz;
-    cseed[iLayer].fC       = curvature;
-    
-  }
-
-  return chi2TR;
-
 }
 
+
 //___________________________________________________________________
-void AliTRDseedV1::Print()
+Bool_t AliTRDseedV1::IsEqual(const TObject *o) const
 {
-  //
-  // Printing the seedstatus
-  //
+  // Checks if current instance of the class has the same essential members
+  // as the given one
 
-       AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
-       Int_t nTimeBins = cal->GetNumberOfTimeBins();
-       
-       printf("Seed status :\n");
-       printf("  fTilt      = %f\n", fTilt);
-       printf("  fPadLength = %f\n", fPadLength);
-       printf("  fX0        = %f\n", fX0);
-       for(int ic=0; ic<nTimeBins; ic++) {
-          const Char_t *isUsable = fUsable[ic]?"Yes":"No";
-         printf("  %d X[%f] Y[%f] Z[%f] Indexes[%d] clusters[%p] usable[%s]\n"
-                , ic
-                , fX[ic]
-                , fY[ic]
-                , fZ[ic]
-                , fIndexes[ic]
-                , ((void*) fClusters[ic])
-                , isUsable);
-        }
+  if(!o) return kFALSE;
+  const AliTRDseedV1 *inTracklet = dynamic_cast<const AliTRDseedV1*>(o);
+  if(!inTracklet) return kFALSE;
 
-       printf("  fYref[0] =%f fYref[1] =%f\n", fYref[0], fYref[1]);
-       printf("  fZref[0] =%f fZref[1] =%f\n", fZref[0], fZref[1]);
-       printf("  fYfit[0] =%f fYfit[1] =%f\n", fYfit[0], fYfit[1]);
-       printf("  fYfitR[0]=%f fYfitR[1]=%f\n", fYfitR[0], fYfitR[1]);
-       printf("  fZfit[0] =%f fZfit[1] =%f\n", fZfit[0], fZfit[1]);
-       printf("  fZfitR[0]=%f fZfitR[1]=%f\n", fZfitR[0], fZfitR[1]);
-       printf("  fSigmaY =%f\n", fSigmaY);
-       printf("  fSigmaY2=%f\n", fSigmaY2);            
-       printf("  fMeanz  =%f\n", fMeanz);
-       printf("  fZProb  =%f\n", fZProb);
-       printf("  fLabels[0]=%d fLabels[1]=%d\n", fLabels[0], fLabels[1]);
-       printf("  fN      =%d\n", fN);
-       printf("  fN2     =%d (>8 isOK)\n",fN2);
-       printf("  fNUsed  =%d\n", fNUsed);
-       printf("  fFreq   =%d\n", fFreq);
-       printf("  fNChange=%d\n",  fNChange);
-       printf("  fMPads  =%f\n", fMPads);
-       
-       printf("  fC      =%f\n", fC);        
-       printf("  fCC     =%f\n",fCC);      
-       printf("  fChi2   =%f\n", fChi2);  
-       printf("  fChi2Z  =%f\n", fChi2Z);
+  for (Int_t i = 0; i < 2; i++){
+    if ( fYref[i] != inTracklet->GetYref(i) ) return kFALSE;
+    if ( fZref[i] != inTracklet->GetZref(i) ) return kFALSE;
+  }
+  
+  if ( fSigmaY != inTracklet->GetSigmaY() ) return kFALSE;
+  if ( fSigmaY2 != inTracklet->GetSigmaY2() ) return kFALSE;
+  if ( fTilt != inTracklet->GetTilt() ) return kFALSE;
+  if ( fPadLength != inTracklet->GetPadLength() ) return kFALSE;
+  
+  for (Int_t i = 0; i < knTimebins; i++){
+    if ( fX[i] != inTracklet->GetX(i) ) return kFALSE;
+    if ( fY[i] != inTracklet->GetY(i) ) return kFALSE;
+    if ( fZ[i] != inTracklet->GetZ(i) ) return kFALSE;
+    if ( fIndexes[i] != inTracklet->GetIndexes(i) ) return kFALSE;
+    if ( fUsable[i] != inTracklet->IsUsable(i) ) return kFALSE;
+  }
 
+  for (Int_t i=0; i < 2; i++){
+    if ( fYfit[i] != inTracklet->GetYfit(i) ) return kFALSE;
+    if ( fZfit[i] != inTracklet->GetZfit(i) ) return kFALSE;
+    if ( fYfitR[i] != inTracklet->GetYfitR(i) ) return kFALSE;
+    if ( fZfitR[i] != inTracklet->GetZfitR(i) ) return kFALSE;
+    if ( fLabels[i] != inTracklet->GetLabels(i) ) return kFALSE;
+  }
+  
+  if ( fMeanz != inTracklet->GetMeanz() ) return kFALSE;
+  if ( fZProb != inTracklet->GetZProb() ) return kFALSE;
+  if ( fN2 != inTracklet->GetN2() ) return kFALSE;
+  if ( fNUsed != inTracklet->GetNUsed() ) return kFALSE;
+  if ( fFreq != inTracklet->GetFreq() ) return kFALSE;
+  if ( fNChange != inTracklet->GetNChange() ) return kFALSE;
+  if ( fNChange != inTracklet->GetNChange() ) return kFALSE;
+   
+  if ( fC != inTracklet->GetC() ) return kFALSE;
+  if ( fCC != inTracklet->GetCC() ) return kFALSE;
+  if ( fChi2 != inTracklet->GetChi2() ) return kFALSE;
+  //  if ( fChi2Z != inTracklet->GetChi2Z() ) return kFALSE;
+
+  if ( fDet != inTracklet->GetDetector() ) return kFALSE;
+  if ( fMom != inTracklet->GetMomentum() ) return kFALSE;
+  if ( fdX != inTracklet->GetdX() ) return kFALSE;
+  
+  for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
+    AliTRDcluster *curCluster = fClusters[iCluster];
+    AliTRDcluster *inCluster = inTracklet->GetClusters(iCluster);
+    if (curCluster && inCluster){
+      if (! curCluster->IsEqual(inCluster) ) {
+        curCluster->Print();
+        inCluster->Print();
+        return kFALSE;
+      }
+    } else {
+      // if one cluster exists, and corresponding 
+      // in other tracklet doesn't - return kFALSE
+      if(curCluster || inCluster) return kFALSE;
+    }
+  }
+  return kTRUE;
 }