X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDtrackingChamber.cxx;h=a432ae79ac3178ba2b14ba22c1a1ccfeec665983;hb=bca5db015a73eeba35a687329a3a9eeb3c5b2e57;hp=5de3712b7b0f74c183275f02b10099814ec725cd;hpb=b0a48c4d0c3a8411792e5741b83f97456a66d277;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TRD/AliTRDtrackingChamber.cxx b/TRD/AliTRDtrackingChamber.cxx
index 5de3712b7b0..a432ae79ac3 100644
--- a/TRD/AliTRDtrackingChamber.cxx
+++ b/TRD/AliTRDtrackingChamber.cxx
@@ -37,84 +37,122 @@
 #include "AliTRDgeometry.h"
 #include "AliTRDpadPlane.h"
 #include "AliTRDcalibDB.h"
+#include "AliTRDCommonParam.h"
 #include "Cal/AliTRDCalDet.h"
 #include "Cal/AliTRDCalROC.h"
 
 ClassImp(AliTRDtrackingChamber)
 
 //_______________________________________________________
-AliTRDtrackingChamber::AliTRDtrackingChamber(Int_t det) :
-  fDetector(det)
+AliTRDtrackingChamber::AliTRDtrackingChamber() 
+  :TObject()
+  ,fDetector(-1)
   ,fX0(0.)
+  // ,fExB(0.)
+  // ,fVD(0.)
+  // ,fT0(0.)
+  // ,fS2PRF(0.)
+  // ,fDiffL(0.)
+  // ,fDiffT(0.)
 {}  
 
 //_______________________________________________________
 void AliTRDtrackingChamber::Clear(const Option_t *opt)
 {
-  for(Int_t itb=0; itb<kNTimeBins; itb++) fTB[itb].Clear(opt);
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++) fTB[itb].Clear(opt);
 }
 
 //_______________________________________________________
-void AliTRDtrackingChamber::InsertCluster(AliTRDcluster *c, Int_t index)
-{
-  fTB[c->GetPadTime()].InsertCluster(c, index);
-}
-
-//_______________________________________________________
-Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *geo, const AliTRDCalDet *cal, Bool_t hlt)
+Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *const geo, Bool_t hlt)
 {
 // Init chamber and all time bins (AliTRDchamberTimeBin)
 // Calculates radial position of the chamber based on 
 // radial positions of the time bins (calibration/alignment aware)
 //
-  Int_t stack = geo->GetStack(fDetector);
-  Int_t layer = geo->GetLayer(fDetector);
+  if(fDetector < 0 || fDetector >= AliTRDgeometry::kNdet){
+    AliWarning(Form("Detector index not set correctly to %d", fDetector));
+    return kFALSE;
+  }
+
+  Int_t stack = AliTRDgeometry::GetStack(fDetector);
+  Int_t layer = AliTRDgeometry::GetLayer(fDetector);
   AliTRDpadPlane *pp = geo->GetPadPlane(layer, stack);
   Double_t zl = pp->GetRow0ROC() - pp->GetRowEndROC();
   Double_t z0 = geo->GetRow0(layer, stack, 0) - zl;
   Int_t nrows = pp->GetNrows();
   
   Int_t index[50], jtb = 0;
-  for(Int_t itb=0; itb<kNTimeBins; itb++){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
     if(!fTB[itb]) continue;
     fTB[itb].SetRange(z0, zl);
     fTB[itb].SetNRows(nrows);
+    fTB[itb].SetPlane(layer);
+    fTB[itb].SetStack(stack);
+    fTB[itb].SetSector(AliTRDgeometry::GetSector(fDetector));
     fTB[itb].BuildIndices();
     index[jtb++] = itb;
   }	
   if(jtb<2) return kFALSE;
-  
-  
-  // ESTIMATE POSITION OF PAD PLANE FOR THIS CHAMBER
-  Double_t x0 = fTB[index[0]].GetX();
-  Double_t x1 = fTB[index[1]].GetX();
-  Double_t dx = (x0 - x1)/(index[1] - index[0]); 
 
-  Int_t t0 = (Int_t)cal->GetValue(fDetector);
+  AliTRDcalibDB *calib = AliTRDcalibDB::Instance();
+  Float_t t0;
   if(!hlt){
-    Double_t mean = 0.0;
-    AliTRDCalROC *roc = AliTRDcalibDB::Instance()->GetT0ROC(fDetector);
-    for(Int_t k = 0; k<roc->GetNchannels(); k++) mean += roc->GetValue(k); 
-    mean /= roc->GetNchannels();
-    t0 = (Int_t)(cal->GetValue(fDetector) + mean);
+    t0    = calib->GetT0Average(fDetector);
+  }else{
+    t0    = calib->GetT0Det()->GetValue(fDetector);
   }
+  // fVD    = calib->GetVdriftAverage(fDetector);
+  // fS2PRF = calib->GetPRFROC(fDetector)->GetMean(); fS2PRF *= fS2PRF;
+  // fExB   = AliTRDCommonParam::Instance()->GetOmegaTau(fVD);
+  // AliTRDCommonParam::Instance()->GetDiffCoeff(fDiffL, fDiffT, fVD);  
 
+  // ESTIMATE POSITION OF PAD PLANE FOR THIS CHAMBER
+  //fTB[Int_t(t0)].SetT0();
+  Double_t x0 = fTB[index[0]].GetX();
+  Double_t x1 = fTB[index[1]].GetX();
+  Double_t dx = (x0 - x1)/(index[1] - index[0]); 
   fX0 = x0 + dx*(index[0] - t0);	
   return kTRUE;
 }
-  
+
 //_______________________________________________________	
 Int_t AliTRDtrackingChamber::GetNClusters() const
 {
+// Basic loop method
 // Returns number of clusters in chamber
 //
   Int_t n = 0;
-  for(Int_t itb=0; itb<kNTimeBins; itb++){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
     n += Int_t(fTB[itb]);
   }
   return n;	
 }	
 
+//_______________________________________________________
+void AliTRDtrackingChamber::Bootstrap(const AliTRDReconstructor *rec)
+{
+// Basic loop method
+// Bootstrap each time bin
+//
+  AliTRDchamberTimeBin *jtb = &fTB[0];
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
+    (*jtb).Bootstrap(rec, fDetector);
+  }
+}
+
+//_______________________________________________________
+void  AliTRDtrackingChamber::SetOwner()
+{
+// Basic loop method
+// Set ownership in time bins
+//
+  AliTRDchamberTimeBin *jtb = &fTB[0];
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
+    if(!(Int_t(*jtb))) continue;
+    (*jtb).SetOwner();
+  }
+}
+
 //_______________________________________________________
 Double_t AliTRDtrackingChamber::GetQuality()
 {
@@ -140,7 +178,7 @@ Double_t AliTRDtrackingChamber::GetQuality()
   Int_t ncl   = 0;
   Int_t nused = 0;
   Int_t nClLayer;
-  for(int itb=0; itb<kNTimeBins; itb++){
+  for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
     if(!(nClLayer = fTB[itb].GetNClusters())) continue;
     ncl += nClLayer;
     for(Int_t incl = 0; incl < nClLayer; incl++){
@@ -168,7 +206,7 @@ Double_t AliTRDtrackingChamber::GetQuality()
 
 
 //_______________________________________________________
-Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry *geo, const AliTRDReconstructor *rec)
+Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer, AliTRDgeometry * const geo, const AliTRDReconstructor *rec)
 {
   //
   // Creates a seeding layer
@@ -202,12 +240,12 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   Int_t hvals[kMaxPads + 1];	memset(hvals, 0, sizeof(Int_t)*kMaxPads);	 // one entry in addition for termination flag
   Float_t *sigmas[kMaxRows];
   Float_t svals[kMaxPads];	memset(svals, 0, sizeof(Float_t)*kMaxPads);	
-  AliTRDcluster *c = 0x0;
+  AliTRDcluster *c = NULL;
   for(Int_t irs = 0; irs < kMaxRows; irs++){
     histogram[irs] = &hvals[irs*kMaxCols];
     sigmas[irs] = &svals[irs*kMaxCols];
   }
-  for(Int_t iTime = timeBinMin; iTime < kNTimeBins-timeBinMax; iTime++){
+  for(Int_t iTime = timeBinMin; iTime < AliTRDseedV1::kNtb-timeBinMax; iTime++){
     if(!(nClusters = fTB[iTime].GetNClusters())) continue;
     z0 = fTB[iTime].GetZ0();
     zl = fTB[iTime].GetDZ0();
@@ -227,8 +265,8 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   Float_t *cogz[kMaxRows];
   
   // Lookup-Table storing coordinates according to the bins
-  Float_t yLengths[kMaxCols];
-  Float_t zLengths[kMaxRows];
+  Float_t yLengths[kMaxCols]; memset(yLengths, 0, kMaxCols*sizeof(Float_t));
+  Float_t zLengths[kMaxRows]; memset(zLengths, 0, kMaxRows*sizeof(Float_t));
   for(Int_t icnt = 0; icnt < nCols; icnt++){
     yLengths[icnt] = pp->GetColPos(nCols - 1 - icnt) + binlength/2;
   }
@@ -270,7 +308,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   Int_t col, row, lower, lower1, upper, upper1;
   for(Int_t ib = 0; ib < nCont; ib++){
     if(nCandidates >= AliTRDtrackerV1::kMaxTracksStack){
-      printf("Number of seed candidates %d exceeded maximum allowed per stack %d", nCandidates, AliTRDtrackerV1::kMaxTracksStack);
+      AliDebug(1, Form("Number of seed candidates %d exceeded maximum allowed per stack %d", nCandidates, AliTRDtrackerV1::kMaxTracksStack));
       break;
     }
     // Positions
@@ -321,7 +359,8 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   
   new(fakeLayer) AliTRDchamberTimeBin(layer, stack, sector, z0, zl);
   fakeLayer->SetReconstructor(rec);
-  AliTRDcluster *cluster = 0x0;
+  fakeLayer->SetNRows(nRows);
+  fakeLayer->SetOwner(kFALSE);
   if(nCandidates){
     UInt_t fakeIndex = 0;
     for(Int_t ican = 0; ican < nCandidates; ican++){
@@ -329,7 +368,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
       col = cand[ican] % nCols;
       //temporary
       Int_t n = 0; Double_t x = 0., y = 0., z = 0.;
-      for(int itb=0; itb<kNTimeBins; itb++){
+      for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
         if(!(nClusters = fTB[itb].GetNClusters())) continue;
         for(Int_t incl = 0; incl < nClusters; incl++){
           c = fTB[itb].GetCluster(incl);	
@@ -341,26 +380,24 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
           n++;
         }
       }
+      if(!n) continue;
       pos[0] = x/n;
       pos[1] = y/n;
       pos[2] = z/n;
       sig[0] = .02;
       sig[1] = sigcands[ican];
-      cluster = new AliTRDcluster(fDetector, 0., pos, sig, 0x0, 3, signal, col, row, 0, 0, 0., 0);
-      fakeLayer->InsertCluster(cluster, fakeIndex++);
+      fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
     }
   }
-  fakeLayer->SetNRows(nRows);
-  fakeLayer->SetOwner();
   fakeLayer->BuildIndices();
-  //fakeLayer->PrintClusters();
+  //fakeLayer->Print();
   
-  if(rec->GetStreamLevel(AliTRDReconstructor::kTracker) >= 3){
+  if(rec->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 3){
     //TMatrixD hist(nRows, nCols);
     //for(Int_t i = 0; i < nRows; i++)
     //	for(Int_t j = 0; j < nCols; j++)
     //		hist(i,j) = histogram[i][j];
-    TTreeSRedirector &cstreamer = *AliTRDtrackerV1::DebugStreamer();
+    TTreeSRedirector &cstreamer = *rec->GetDebugStream(AliTRDrecoParam::kTracker);
     cstreamer << "GetSeedingLayer"
     << "layer="      << layer
     << "ymin="       << ymin
@@ -375,3 +412,28 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
   return kTRUE;
 }
 
+
+//_______________________________________________________
+void AliTRDtrackingChamber::Print(Option_t *opt) const
+{
+  // Print the chamber status
+  if(!GetNClusters()) return;
+  AliInfo(Form("fDetector   = %d", fDetector));
+  AliInfo(Form("fX0         = %7.3f", fX0));
+  const AliTRDchamberTimeBin *itb = &fTB[0];
+  for(Int_t jtb=0; jtb<AliTRDseedV1::kNtb; jtb++, itb++) (*itb).Print(opt);
+}
+
+
+//_______________________________________________________
+void AliTRDtrackingChamber::Update()
+{
+// Steer purging of used and shared clusters 
+
+  AliTRDchamberTimeBin *jtb = &fTB[0];
+  for(Int_t itb=AliTRDseedV1::kNtb; itb--; ++jtb){ 
+    if(!(Int_t(*jtb))) continue;
+    (*jtb).BuildIndices();
+  }
+}
+