+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
//_____________________________________________________________________________
-Bool_t AliTRDtrackerV1::GetTrackPoint(Int_t /*index*/, AliTrackPoint &/*p*/) const
+Bool_t AliTRDtrackerV1::GetTrackPoint(Int_t index, AliTrackPoint &/*p*/) const
{
//AliInfo(Form("Asking for tracklet %d", index));
Int_t nseed = 0; // contor for loaded seeds
Int_t found = 0; // contor for updated TRD tracks
+
+ // Calibration monitor
+ AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
+ if (!calibra) AliInfo("Could not get Calibra instance\n");
+
+
AliTRDtrackV1 track;
for (Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++) {
AliESDtrack *seed = event->GetTrack(itrack);
track.ResetCovariance(50.0);
// do the propagation and processing
- FollowProlongation(track);
- // computes PID for track
- track.CookPID();
- // update calibration references using this track
- //track.Calibrate();
-
- // Prolongate to TPC
- Double_t xTPC = 250.0;
- if (PropagateToX(track, xTPC, fgkMaxStep)) { // -with update
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDrefit);
- track.UpdateESDtrack(seed);
- // Add TRD track to ESDfriendTrack
- if (AliTRDReconstructor::StreamLevel() > 0 /*&& quality TODO*/){
- AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
- calibTrack->SetOwner();
- seed->AddCalibObject(calibTrack);
+ Bool_t kUPDATE = kFALSE;
+ Double_t xTPC = 250.0;
+ if(FollowProlongation(track)){
+ // computes PID for track
+ track.CookPID();
+ // update calibration references using this track
+ if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
+
+ // Prolongate to TPC
+ if (PropagateToX(track, xTPC, fgkMaxStep)) { // -with update
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDrefit);
+ track.UpdateESDtrack(seed);
+ // Add TRD track to ESDfriendTrack
+ if (AliTRDReconstructor::StreamLevel() > 0 /*&& quality TODO*/){
+ AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
+ calibTrack->SetOwner();
+ seed->AddCalibObject(calibTrack);
+ }
+ found++;
+ kUPDATE = kTRUE;
}
- found++;
- } else { // - without update
+ }
+
+ // Prolongate to TPC without update
+ if(!kUPDATE) {
AliTRDtrackV1 tt(*seed);
if (PropagateToX(tt, xTPC, fgkMaxStep)) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDrefit);
}
//AliInfo("");
Int_t nClustersExpected = 0;
+ Float_t clength = AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
Int_t lastplane = 5; //GetLastPlane(&t);
for (Int_t iplane = lastplane; iplane >= 0; iplane--) {
//AliInfo(Form("plane %d", iplane));
Int_t index = 0;
//AliInfo(Form("sector %d", sector));
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
- //AliInfo(Form("tracklet 0x%x @ %d", tracklet, index));
+ //AliInfo(Form("tracklet %p @ %d", tracklet, index));
if(!tracklet) continue;
-
- t.PropagateTo(tracklet->GetX0(), xx0, xrho); // not correct
+ //AliInfo(Form("reco %p", tracklet->GetRecoParam()));
+ t.SetTracklet(tracklet, iplane, index);
+
+ t.PropagateTo(tracklet->GetX0() - clength, xx0, xrho);
if (!AdjustSector(&t)) break;
Double_t maxChi2 = t.GetPredictedChi2(tracklet);
//
Int_t nClustersExpected = 0;
-
// Loop through the TRD planes
for (Int_t iplane = 0; iplane < AliTRDgeometry::Nplan(); iplane++) {
//AliInfo(Form("Processing plane %d ...", iplane));
stackLayer[itb].BuildIndices();
nClustersChmb += stackLayer[itb].GetNClusters();
}
+ if(!nClustersChmb) continue;
//AliInfo(Form("Detector p[%d] c[%d]. Building tracklet from %d clusters ... ", iplane, ichmb, nClustersChmb));
tracklet.SetRecoParam(fRecoParam);
tracklet.SetTilt(TMath::Tan(-TMath::DegToRad()*pp->GetTiltingAngle()));
tracklet.SetPadLength(pp->GetLengthIPad());
tracklet.SetPlane(iplane);
- Int_t tbRange = fTimeBinsPerPlane; //Int_t(AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght() * AliTRDCommonParam::Instance()->GetSamplingFrequency()/AliTRDcalibDB::Instance()->GetVdriftDet()->GetValue(det));
+ //Int_t tbRange = fTimeBinsPerPlane; //Int_t(AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght() * AliTRDCommonParam::Instance()->GetSamplingFrequency()/AliTRDcalibDB::Instance()->GetVdriftDet()->GetValue(det));
//printf("%d hl[%f] pl[%f] tb[%d]\n", il, hL[il], padlength[il], tbRange[il]);
- tracklet.SetNTimeBinsRange(tbRange);
+ //tracklet.SetNTimeBinsRange(tbRange);
tracklet.SetX0(x0);
tracklet.Init(&t);
if(!tracklet.AttachClustersIter(stackLayer, 1000.)) continue;
+ tracklet.Init(&t);
//if(!tracklet.AttachClusters(stackLayer, kTRUE)) continue;
//if(!tracklet.Fit()) continue;
return nClustersExpected;
}
+//_____________________________________________________________________________
+Int_t AliTRDtrackerV1::PropagateToX(AliTRDtrackV1 &t, Double_t xToGo, Double_t maxStep)
+{
+ //
+ // Starting from current X-position of track <t> this function
+ // extrapolates the track up to radial position <xToGo>.
+ // Returns 1 if track reaches the plane, and 0 otherwise
+ //
+
+ const Double_t kEpsilon = 0.00001;
+
+ // Current track X-position
+ Double_t xpos = t.GetX();
+
+ // Direction: inward or outward
+ Double_t dir = (xpos < xToGo) ? 1.0 : -1.0;
+
+ while (((xToGo - xpos) * dir) > kEpsilon) {
+
+ Double_t xyz0[3];
+ Double_t xyz1[3];
+ Double_t param[7];
+ Double_t x;
+ Double_t y;
+ Double_t z;
+
+ // The next step size
+ Double_t step = dir * TMath::Min(TMath::Abs(xToGo-xpos),maxStep);
+
+ // Get the global position of the starting point
+ t.GetXYZ(xyz0);
+
+ // X-position after next step
+ x = xpos + step;
+
+ // Get local Y and Z at the X-position of the next step
+ if (!t.GetProlongation(x,y,z)) {
+ return 0; // No prolongation possible
+ }
+
+ // The global position of the end point of this prolongation step
+ xyz1[0] = x * TMath::Cos(t.GetAlpha()) - y * TMath::Sin(t.GetAlpha());
+ xyz1[1] = +x * TMath::Sin(t.GetAlpha()) + y * TMath::Cos(t.GetAlpha());
+ xyz1[2] = z;
+
+ // Calculate the mean material budget between start and
+ // end point of this prolongation step
+ AliTracker::MeanMaterialBudget(xyz0,xyz1,param);
+
+ // Propagate the track to the X-position after the next step
+ if (!t.PropagateTo(x,param[1],param[0]*param[4])) {
+ return 0;
+ }
+
+ // Rotate the track if necessary
+ AdjustSector(&t);
+
+ // New track X-position
+ xpos = t.GetX();
+
+ }
+
+ return 1;
+
+}
+
//____________________________________________________________________
void AliTRDtrackerV1::UnloadClusters()
{
Int_t nentr;
nentr = fClusters->GetEntriesFast();
- //AliInfo(Form("clearing %d clusters", nentr));
for (i = 0; i < nentr; i++) {
delete fClusters->RemoveAt(i);
}
fNclusters = 0;
-
- nentr = fTracklets->GetEntriesFast();
- //AliInfo(Form("clearing %d tracklets", nentr));
- for (i = 0; i < nentr; i++) {
- delete fTracklets->RemoveAt(i);
- }
+
+ if(fTracklets){
+ for (i = 0; i < fTracklets->GetEntriesFast(); i++) delete fTracklets->RemoveAt(i);
+ }
nentr = fSeeds->GetEntriesFast();
- //AliInfo(Form("clearing %d seeds", nentr));
for (i = 0; i < nentr; i++) {
delete fSeeds->RemoveAt(i);
}
nentr = fTracks->GetEntriesFast();
- //AliInfo(Form("clearing %d tracks", nentr));
for (i = 0; i < nentr; i++) {
delete fTracks->RemoveAt(i);
}
}
//____________________________________________________________________
-Int_t AliTRDtrackerV1::SetTracklet(AliTRDseedV1 */*tracklet*/)
+Int_t AliTRDtrackerV1::SetTracklet(AliTRDseedV1 *tracklet)
{
// Add this tracklet to the list of tracklets stored in the tracker
//
fTracklets->SetOwner(kTRUE);
}
Int_t nentries = fTracklets->GetEntriesFast();
- //AliTRDseedV1 *t = new ((*fTracklets)[nentries]) AliTRDseedV1(*tracklet);
- //AliInfo(Form("0x%x @ %d", t, nentries));
+ new ((*fTracklets)[nentries]) AliTRDseedV1(*tracklet);
return nentries;
}
#endif
// Init chambers geometry
- Int_t det, tbRange[6]; // time bins inside the detector geometry
+ Int_t det/*, tbRange[6]*/; // time bins inside the detector geometry
Double_t hL[kNPlanes]; // Tilting angle
Float_t padlength[kNPlanes]; // pad lenghts
AliTRDpadPlane *pp;
hL[il] = TMath::Tan(-TMath::DegToRad()*pp->GetTiltingAngle());
padlength[il] = pp->GetLengthIPad();
det = il; // to be fixed !!!!!
- tbRange[il] = fTimeBinsPerPlane; //Int_t(AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght() * AliTRDCommonParam::Instance()->GetSamplingFrequency()/AliTRDcalibDB::Instance()->GetVdriftDet()->GetValue(det));
+ //tbRange[il] = fTimeBinsPerPlane; //Int_t(AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght() * AliTRDCommonParam::Instance()->GetSamplingFrequency()/AliTRDcalibDB::Instance()->GetVdriftDet()->GetValue(det));
//printf("%d hl[%f] pl[%f] tb[%d]\n", il, hL[il], padlength[il], tbRange[il]);
}
tseed->SetPlane(jLayer);
tseed->SetTilt(hL[jLayer]);
tseed->SetPadLength(padlength[jLayer]);
- tseed->SetNTimeBinsRange(tbRange[jLayer]);
+ //tseed->SetNTimeBinsRange(tbRange[jLayer]);
tseed->SetX0(layer[iLayer]->GetX());//layers[jLayer*fTimeBinsPerPlane].GetX());
tseed->Init(fFitter->GetRiemanFitter());
cseed[jLayer].SetTilt(hL[jLayer]);
cseed[jLayer].SetX0(layers[(jLayer +1) * fTimeBinsPerPlane-1].GetX());
cseed[jLayer].SetPadLength(padlength[jLayer]);
- cseed[jLayer].SetNTimeBinsRange(tbRange[jLayer]);
+ //cseed[jLayer].SetNTimeBinsRange(tbRange[jLayer]);
cseed[jLayer].Init(rim);
// AliTRDcluster *cd = FindSeedingCluster(&layers[jLayer*fTimeBinsPerPlane], &cseed[jLayer]);
// if(cd == 0x0) continue;
Float_t nclMed = float(ncl-nused)/nTimeBins;
Int_t ncli = Int_t(nclMed);
Float_t nclDev = TMath::Abs(nclMed - TMath::Max(ncli, 1));
- nclDev -= (nclDev>.5) && ncli ? .5 : 0.;
- /*Double_t quality = */ return TMath::Exp(-2.*nclDev);
-
+ nclDev -= (nclDev>.5) && ncli ? 0. : 1.;
+ /*Double_t quality = */ return TMath::Exp(2.*nclDev);
+
// // get slope of the derivative
// if(!fitter.Eval()) return quality;
// fitter.PrintResults(3);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff