// get detector for this tracklet
AliTRDcluster *cl = 0x0;
- Int_t ic = 0; do; while(!(cl = tracklet->GetClusters(ic++)));
+ Int_t ic = 0; do {} while(!(cl = tracklet->GetClusters(ic++)));
Int_t idet = cl->GetDetector();
Double_t local[3];
// Do the back prolongation
new(&track) AliTRDtrackV1(*seed);
- //track->Print();
+ track.SetReconstructor(fReconstructor);
+
//Int_t lbl = seed->GetLabel();
//track.SetSeedLabel(lbl);
// update calibration references using this track
if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
// save calibration object
+ if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0 /*&& quality TODO*/){
+ AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
+ calibTrack->SetOwner();
+ seed->AddCalibObject(calibTrack);
+ }
+ //update ESD track
if ((track.GetNumberOfClusters() > 15) && (track.GetNumberOfClusters() > 0.5*expectedClr)) {
seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
-
track.UpdateESDtrack(seed);
-
- // Add TRD track to ESDfriendTrack
- if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0 /*&& quality TODO*/){
- AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
- calibTrack->SetOwner();
- seed->AddCalibObject(calibTrack);
- }
}
}
xyz1[1] = x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
xyz1[2] = z;
- // Get material budget
- Double_t param[7];
- AliTracker::MeanMaterialBudget(xyz0, xyz1, param);
- Double_t xrho= param[0]*param[4];
- Double_t xx0 = param[1]; // Get mean propagation parameters
-
- // Propagate and update
- t.PropagateTo(x, xx0, xrho);
- if (!AdjustSector(&t)) break;
+ Double_t length = TMath::Sqrt(
+ (xyz0[0]-xyz1[0])*(xyz0[0]-xyz1[0]) +
+ (xyz0[1]-xyz1[1])*(xyz0[1]-xyz1[1]) +
+ (xyz0[2]-xyz1[2])*(xyz0[2]-xyz1[2])
+ );
+ if(length>0.){
+ // Get material budget
+ Double_t param[7];
+ if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param)<=0.) break;
+ Double_t xrho= param[0]*param[4];
+ Double_t xx0 = param[1]; // Get mean propagation parameters
+
+ // Propagate and update
+ t.PropagateTo(x, xx0, xrho);
+ if (!AdjustSector(&t)) break;
+ }
Double_t maxChi2 = t.GetPredictedChi2(tracklet);
if (maxChi2 < 1e+10 && t.Update(tracklet, maxChi2)){
if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
Int_t index;
- for(int iplane=0; iplane<6; iplane++){
+ for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
if(!tracklet) continue;
t.SetTracklet(tracklet, index);
if((x = fTrSec[sector].GetX(ilayer)) < 1.) continue;
- if (!t.GetProlongation(x, y, z)) return -nClustersExpected;
+ if (!t.GetProlongation(x, y, z)) return -1/*nClustersExpected*/;
Int_t stack = fGeom->GetStack(z, ilayer);
Int_t nCandidates = stack >= 0 ? 1 : 2;
z -= stack >= 0 ? 0. : 4.;
AliTRDpadPlane *pp = fGeom->GetPadPlane(ilayer, stack);
tracklet.SetTilt(TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle()));
tracklet.SetPadLength(pp->GetLengthIPad());
- tracklet.SetPlane(ilayer);
+ tracklet.SetDetector(chamber->GetDetector());
tracklet.SetX0(x);
if(!tracklet.Init(&t)){
t.SetStopped(kTRUE);
return nClustersExpected;
}
- if(!tracklet.AttachClustersIter(chamber, 1000.)) continue;
+ if(!tracklet.AttachClustersIter(chamber, 1000./*, kTRUE*/)) continue;
tracklet.Init(&t);
if(tracklet.GetN() < fgNTimeBins*fReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
}
if(!ptrTracklet->IsOK()){
if(x < 1.) continue; //temporary
- if(!PropagateToX(t, x-fgkMaxStep, fgkMaxStep)) return -nClustersExpected;
- if(!AdjustSector(&t)) return -nClustersExpected;
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) return -nClustersExpected;
+ if(!PropagateToX(t, x-fgkMaxStep, fgkMaxStep)) return -1/*nClustersExpected*/;
+ if(!AdjustSector(&t)) return -1/*nClustersExpected*/;
+ if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) return -1/*nClustersExpected*/;
continue;
}
// Propagate closer to the current chamber if neccessary
x -= clength;
- if (x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x-fgkMaxStep, fgkMaxStep)) return -nClustersExpected;
- if (!AdjustSector(&t)) return -nClustersExpected;
- if (TMath::Abs(t.GetSnp()) > fgkMaxSnp) return -nClustersExpected;
+ if (x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x-fgkMaxStep, fgkMaxStep)) return -1/*nClustersExpected*/;
+ if (!AdjustSector(&t)) return -1/*nClustersExpected*/;
+ if (TMath::Abs(t.GetSnp()) > fgkMaxSnp) return -1/*nClustersExpected*/;
// load tracklet to the tracker and the track
ptrTracklet = SetTracklet(ptrTracklet);
t.GetXYZ(xyz0);
alpha = t.GetAlpha();
x = ptrTracklet->GetX0();
- if (!t.GetProlongation(x, y, z)) return -nClustersExpected;
+ if (!t.GetProlongation(x, y, z)) return -1/*nClustersExpected*/;
Double_t xyz1[3]; // exit point
xyz1[0] = x * TMath::Cos(alpha) - y * TMath::Sin(alpha);
xyz1[1] = +x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
xyz1[2] = z;
Double_t param[7];
- AliTracker::MeanMaterialBudget(xyz0, xyz1, param);
+ if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param)<=0.) return -1;
// The mean propagation parameters
Double_t xrho = param[0]*param[4]; // density*length
Double_t xx0 = param[1]; // radiation length
// Propagate and update track
- if (!t.PropagateTo(x, xx0, xrho)) return -nClustersExpected;
- if (!AdjustSector(&t)) return -nClustersExpected;
+ if (!t.PropagateTo(x, xx0, xrho)) return -1/*nClustersExpected*/;
+ if (!AdjustSector(&t)) return -1/*nClustersExpected*/;
Double_t maxChi2 = t.GetPredictedChi2(ptrTracklet);
- if (!t.Update(ptrTracklet, maxChi2)) return -nClustersExpected;
+ if (!t.Update(ptrTracklet, maxChi2)) return -1/*nClustersExpected*/;
if (maxChi2<1e+10) {
nClustersExpected += ptrTracklet->GetN();
//t.SetTracklet(&tracklet, index);
Double_t c = fitter->GetParameter(2);
Double_t y0 = 1. / a;
Double_t x0 = -b * y0;
- Double_t R = TMath::Sqrt(y0*y0 + x0*x0 - c*y0);
+ Double_t tmp = y0*y0 + x0*x0 - c*y0;
+ if(tmp<=0.) return 1.E10;
+ Double_t R = TMath::Sqrt(tmp);
Double_t C = 1.0 + b*b - c*a;
if (C > 0.0) C = a / TMath::Sqrt(C);
if(!track){
for(Int_t ip = 0; ip < kNPlanes; ip++) {
x = tracklets[ip].GetX0();
- Double_t tmp = TMath::Sqrt(R*R-(x-x0)*(x-x0));
+ tmp = R*R-(x-x0)*(x-x0);
+ if(tmp <= 0.) continue;
+ tmp = TMath::Sqrt(tmp);
// y: R^2 = (x - x0)^2 + (y - y0)^2
// => y = y0 +/- Sqrt(R^2 - (x - x0)^2)
Float_t xyz[3];
for(int ip=0; ip<np; ip++){
points[ip].GetXYZ(xyz);
- xyz[1] = y0 - (y0>0.?1.:-1)*TMath::Sqrt(R*R-(xyz[0]-x0)*(xyz[0]-x0));
+ xyz[1] = y0 - (y0>0.?1.:-1.)*TMath::Sqrt(R*R-(xyz[0]-x0)*(xyz[0]-x0));
xyz[2] = z0 + dzdx * (xyz[0] - xref);
points[ip].SetXYZ(xyz);
}
}
-/* if(fReconstructor->GetStreamLevel() >=5){
- TTreeSRedirector &cstreamer = *fgDebugStreamer;
- Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
- Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- Double_t chi2z = CalculateChi2Z(tracklets, z0, dzdx, xref);
- cstreamer << "FitRiemanTilt"
- << "EventNumber=" << eventNumber
- << "CandidateNumber=" << candidateNumber
- << "xref=" << xref
- << "Chi2Z=" << chi2z
- << "\n";
- }*/
return chi2;
}
xyz1[1] = +x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
xyz1[2] = z;
Double_t param[7];
- AliTracker::MeanMaterialBudget(xyz0, xyz1, param);
+ if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param)<=0.) break;
Double_t xrho = param[0]*param[4]; // density*length
Double_t xx0 = param[1]; // radiation length
// Calculate the mean material budget between start and
// end point of this prolongation step
- AliTracker::MeanMaterialBudget(xyz0, xyz1, param);
+ if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param)<=0.) return 0;
// Propagate the track to the X-position after the next step
if (!t.PropagateTo(x,param[1],param[0]*param[4])) {
branch->SetAddress(&clusterArray);
if(!fClusters){
- array = new TClonesArray("AliTRDcluster", nsize);
+ Float_t nclusters = fReconstructor->GetRecoParam()->GetNClusters();
+ if(fReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
+ array = new TClonesArray("AliTRDcluster", Int_t(nclusters));
array->SetOwner(kTRUE);
}
fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, icl);
}
-
+
+ const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){
if(!fTrSec[isector].GetNChambers()) continue;
- fTrSec[isector].Init(fReconstructor);
+ fTrSec[isector].Init(fReconstructor, cal);
}
return nin;
if(fTracks) fTracks->Delete();
if(fTracklets) fTracklets->Delete();
- if(fClusters && IsClustersOwner()) fClusters->Delete();
if(fClusters){
if(IsClustersOwner()) fClusters->Delete();
// 8. Build ESD track and register it to the output list
//
+ const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
AliTRDtrackingChamber *chamber = 0x0;
AliTRDseedV1 sseed[kMaxTracksStack*6]; // to be initialized
Int_t pars[4]; // MakeSeeds parameters
AliInfo(Form("Plane config %d %d %d Quality %f"
, configs[0], configs[1], configs[2], quality));
}
+
// Initialize contors
Int_t ntracks, // number of TRD track candidates
ntracks1, // number of registered TRD tracks/iter
ntracks2 = 0; // number of all registered TRD tracks in stack
fSieveSeeding = 0;
+
+ // Get stack index
+ Int_t ic = 0; AliTRDtrackingChamber **cIter = &stack[0];
+ while(ic<kNPlanes && !(*cIter)){ic++; cIter++;}
+ if(!(*cIter)) return ntracks2;
+ Int_t istack = fGeom->GetStack((*cIter)->GetDetector());
+
do{
// Loop over seeding configurations
ntracks = 0; ntracks1 = 0;
for (Int_t iconf = 0; iconf<3; iconf++) {
pars[0] = configs[iconf];
pars[1] = ntracks;
+ pars[2] = istack;
ntracks = MakeSeeds(stack, &sseed[6*ntracks], pars);
if(ntracks == kMaxTracksStack) break;
}
if(TMath::Abs(sseed[jseed].GetYfit(1) - sseed[jseed].GetYfit(1)) >= .2) continue; // check this condition with Marian
sseed[jseed].UseClusters();
if(!cl){
- Int_t ic = 0;
+ ic = 0;
while(!(cl = sseed[jseed].GetClusters(ic))) ic++;
clusterIndex = sseed[jseed].GetIndexes(ic);
}
for(Int_t ip = 0; ip < kNPlanes; ip++){
if(!(chamber = stack[ip])) continue;
- chamber->Build(fGeom);//Indices(fSieveSeeding);
+ chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
}
if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
// Default positions for the anode wire in all 6 Layers in case of a stack with missing clusters
// Positions taken using cosmic data taken with SM3 after rebuild
- Double_t x_def[kNPlanes] = {300.2, 312.8, 325.4, 338, 350.6, 363.2};
+ Double_t x_def[kNPlanes] = {300.2, 312.8, 325.4, 338.0, 350.6, 363.2};
// this should be data member of AliTRDtrack
Double_t seedQuality[kMaxTracksStack];
// unpack control parameters
Int_t config = ipar[0];
Int_t ntracks = ipar[1];
+ Int_t istack = ipar[2];
Int_t planes[kNSeedPlanes]; GetSeedingConfig(config, planes);
Int_t planesExt[kNPlanes-kNSeedPlanes]; GetExtrapolationConfig(config, planesExt);
// Init chambers geometry
- Int_t ic = 0; while(!(chamber = stack[ic])) ic++;
- Int_t istack = fGeom->GetStack(chamber->GetDetector());
Double_t hL[kNPlanes]; // Tilting angle
Float_t padlength[kNPlanes]; // pad lenghts
AliTRDpadPlane *pp = 0x0;
AliInfo(Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
}
+ // Build seeding layers
ResetSeedTB();
Int_t nlayers = 0;
for(int isl=0; isl<kNSeedPlanes; isl++){
if(!chamber->GetSeedingLayer(fSeedTB[isl], fGeom, fReconstructor)) continue;
nlayers++;
}
- if(nlayers < 4) return 0;
+ if(nlayers < 4) return ntracks;
// Start finding seeds
FitRieman(c, chi2);
- AliTRDseedV1 *tseed = 0x0;
- for(int iLayer=0; iLayer<kNPlanes; iLayer++){
- tseed = &cseed[iLayer];
- tseed->SetPlane(iLayer);
+ AliTRDseedV1 *tseed = &cseed[0];
+ AliTRDtrackingChamber **cIter = &stack[0];
+ for(int iLayer=0; iLayer<kNPlanes; iLayer++, tseed++, cIter++){
+ tseed->SetDetector((*cIter) ? (*cIter)->GetDetector() : -1);
tseed->SetTilt(hL[iLayer]);
tseed->SetPadLength(padlength[iLayer]);
tseed->SetReconstructor(fReconstructor);
- Double_t x_anode = stack[iLayer] ? stack[iLayer]->GetX() : x_def[iLayer];
- tseed->SetX0(x_anode);
+ tseed->SetX0((*cIter) ? (*cIter)->GetX() : x_def[iLayer]);
tseed->Init(GetRiemanFitter());
}
if (nc < 30) return 0x0;
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
+ ptrTrack->SetReconstructor(fReconstructor);
ptrTrack->CookLabel(.9);
// computes PID for track
Double_t chi2y = GetChi2Y(&cseed[0]);
Double_t chi2z = GetChi2Z(&cseed[0]);
- Int_t nclusters = 0;
+ Float_t nclusters = 0.;
Double_t sumda = 0.;
for(UChar_t ilayer = 0; ilayer < 4; ilayer++){
Int_t jlayer = planes[ilayer];
nclusters += cseed[jlayer].GetN2();
sumda += TMath::Abs(cseed[jlayer].GetYfitR(1) - cseed[jlayer].GetYref(1));
}
- Double_t likea = TMath::Exp(-sumda * fRecoPars->GetPhiCut());
+ nclusters *= .25;
+
+ Double_t likea = TMath::Exp(-sumda * fRecoPars->GetPhiSlope());
Double_t likechi2y = 0.0000000001;
- if (fReconstructor->IsCosmic() || chi2y < 0.5) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YCut());
- Double_t likechi2z = TMath::Exp(-chi2z * fRecoPars->GetChi2ZCut());
- Double_t likeN = TMath::Exp(-(fRecoPars->GetMeanNclusters() - nclusters) / fRecoPars->GetSigmaNclusters());
+ if (fReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
+ Double_t likechi2z = TMath::Exp(-chi2z * fRecoPars->GetChi2ZSlope());
+ Double_t likeN = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
Double_t like = likea * likechi2y * likechi2z * likeN;
// AliInfo(Form("sumda(%f) chi2[0](%f) chi2[1](%f) likea(%f) likechi2y(%f) likechi2z(%f) nclusters(%d) likeN(%f)", sumda, chi2[0], chi2[1], likea, likechi2y, likechi2z, nclusters, likeN));
return like;
}
-
-
//____________________________________________________________________
void AliTRDtrackerV1::GetSeedingConfig(Int_t iconfig, Int_t planes[4])
{
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff