#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcalibDB.h"
+#include "AliTRDCommonParam.h"
#include "Cal/AliTRDCalDet.h"
#include "Cal/AliTRDCalROC.h"
: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
return kFALSE;
}
- Int_t stack = geo->GetStack(fDetector);
- Int_t layer = geo->GetLayer(fDetector);
+ 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);
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
{
// 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;
// Bootstrap each time bin
//
AliTRDchamberTimeBin *jtb = &fTB[0];
- for(Int_t itb=0; itb<kNTimeBins; itb++, ++jtb){
+ for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){
(*jtb).Bootstrap(rec, fDetector);
}
}
// Set ownership in time bins
//
AliTRDchamberTimeBin *jtb = &fTB[0];
- for(Int_t itb=0; itb<kNTimeBins; itb++, ++jtb){
+ for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){
if(!(Int_t(*jtb))) continue;
(*jtb).SetOwner();
}
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++){
//_______________________________________________________
-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
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();
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;
}
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
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);
pos[2] = z/n;
sig[0] = .02;
sig[1] = sigcands[ican];
- fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, 0x0, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
+ fakeLayer->InsertCluster(new AliTRDcluster(fDetector, 0., pos, sig, NULL, 3, signal, col, row, 0, 0, 0., 0), fakeIndex++);
}
}
fakeLayer->BuildIndices();
//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
//_______________________________________________________
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<kNTimeBins; jtb++, itb++) (*itb).Print(opt);
+ 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();
+ }
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff