// loop over the clusters
////////////////////////////
Int_t nbclusters = 0;
- for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
- if(!(cl = tracklet->GetClusters(ic))) continue;
+ for(int jc=0; jc<AliTRDseed::knTimebins; jc++){
+ if(!(cl = tracklet->GetClusters(jc))) continue;
nbclusters++;
// Store the info bis of the tracklet
Int_t group[2] = {0,0};
if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,row,col);
if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,row,col);
- StoreInfoCHPHtrack(cl, tracklet->GetdQdl(ic),group,row,col);
+ StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col);
}
////////////////////////////////////////
Double_t time = cl->GetPadTime();
//Calculate x if possible
Float_t xcenter = 0.0;
- Bool_t echec = kTRUE;
+ Bool_t echec1 = kTRUE;
if((time<=7) || (time>=21)) continue;
// Center 3 balanced: position with the center of the pad
if ((((Float_t) signals[3]) > 0.0) &&
(((Float_t) signals[2]) > 0.0) &&
(((Float_t) signals[4]) > 0.0)) {
- echec = kFALSE;
+ echec1 = kFALSE;
// Security if the denomiateur is 0
if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
/ ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
}
else {
- echec = kTRUE;
+ echec1 = kTRUE;
}
}
if(TMath::Abs(xcenter) > 0.5) echec = kTRUE;
if((time<=7) || (time>=21)) continue;
Short_t *signals = cl->GetSignals();
Float_t xcenter = 0.0;
- Bool_t echec = kTRUE;
+ Bool_t echec1 = kTRUE;
/////////////////////////////////////////////////////////////
// Center 3 balanced: position with the center of the pad
if ((((Float_t) signals[3]) > 0.0) &&
(((Float_t) signals[2]) > 0.0) &&
(((Float_t) signals[4]) > 0.0)) {
- echec = kFALSE;
+ echec1 = kFALSE;
// Security if the denomiateur is 0
if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
/ ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
}
else {
- echec = kTRUE;
+ echec1 = kTRUE;
}
}
- if(TMath::Abs(xcenter) > 0.5) echec = kTRUE;
- if(echec) continue;
+ if(TMath::Abs(xcenter) > 0.5) echec1 = kTRUE;
+ if(echec1) continue;
////////////////////////////////////////////////////////
- //if no echec: calculate with the position of the pad
+ //if no echec1: calculate with the position of the pad
// Position of the cluster
// fill the linear fitter
///////////////////////////////////////////////////////
Bool_t something = kTRUE;
if(!calvect->GetCHEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("CH");
- name += idect;
- projch = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) name);
+ TString tname("CH");
+ tname += idect;
+ projch = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) tname);
projch->SetDirectory(0);
for (Int_t k = 0; k < calvect->GetNumberBinCharge(); k++) {
nentries += projch->GetBinContent(k+1);
Bool_t something = kTRUE;
if(!calvect->GetPHEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PH");
- name += idect;
- projph = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name)));
+ TString tname("PH");
+ tname += idect;
+ projph = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)));
projph->SetDirectory(0);
}
//printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
Bool_t something = kTRUE;
if(!calvect->GetPRFEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PRF");
- name += idect;
- projprf = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name)));
+ TString tname("PRF");
+ tname += idect;
+ projprf = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)));
projprf->SetDirectory(0);
}
// This detector has not enough statistics or was off
Bool_t something = kTRUE;
if(!calvect->GetPRFEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PRF");
- name += idect;
- projprftree = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name);
+ TString tname("PRF");
+ tname += idect;
+ projprftree = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname);
nbins = projprftree->GetN();
arrayx = (Double_t *)projprftree->GetX();
arraye = (Double_t *)projprftree->GetEX();
}
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t kError)
+Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t bError)
{
//
// Fit methode for the sigma of the pad response function
errorm = 0.0;
errorn = 0.0;
error = 0.0;
- if(!kError){
+ if(!bError){
if((valueI + 0.01) > 0.0) errorm = TMath::Log((valueI + 0.01)/valueI);
if((valueI - 0.01) > 0.0) errorn = TMath::Log((valueI - 0.01)/valueI);
error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
"errorm="<<errorm<<
"errorn="<<errorn<<
"error="<<error<<
- "kError="<<kError<<
+ "bError="<<bError<<
"\n";
}
}
if((chi2/(*param)[2]) > 0.1){
- if(kError){
+ if(bError){
chi2 = FitGausMI(arraye,arraym,arrayme,nBins,xMin,xMax,param,kFALSE);
}
else return -4.0;
AliTRDQAChecker& operator = (const AliTRDQAChecker& qac) ;
virtual ~AliTRDQAChecker() {;} // dtor
- virtual const Double_t Check(AliQA::ALITASK_t index) {return 1.0;}
+ virtual const Double_t Check(AliQA::ALITASK_t /*index*/) {return 1.0;}
virtual const Double_t Check(TList * /*list*/) {return 1.0;}
- virtual const Double_t Check(AliQA::ALITASK_t index, TObjArray * /*list*/) {return 1.0;}
+ virtual const Double_t Check(AliQA::ALITASK_t /*index*/, TObjArray * /*list*/) {return 1.0;}
private:
// dedx
- for(Int_t i=0; i<4; i++) {
+ for(Int_t k=0; k<4; ++k) {
Double_t dedx = 0;
for(Int_t j=0; j<6; j++) {
- dedx += track->GetTRDslice(j, i-1);
+ dedx += track->GetTRDslice(j, k-1);
}
GetESDsData(41+i)->Fill(paramOut->GetP(), dedx/6.);
}
// probabilities
if (status & AliESDtrack::kTRDpid) {
- for(Int_t i=0; i<AliPID::kSPECIES; i++)
- GetESDsData(36+i)->Fill(track->GetTRDpid(i));
+ for(Int_t k=0; k<AliPID::kSPECIES; ++k)
+ GetESDsData(36+k)->Fill(track->GetTRDpid(k));
}
// probabilities uniformity
// the right place in the arrays fSurveyX etc.
TObjArray *points = so->GetData();
- for (int i = 0; i<points->GetEntries(); i++) {
- AliSurveyPoint *po = (AliSurveyPoint *) points->At(i);
+ for (int ip = 0; ip<points->GetEntries(); ++ip) {
+ AliSurveyPoint *po = (AliSurveyPoint *) points->At(ip);
TString pna = po->GetPointName();
Int_t i,j,k,l;
if (DecodeSurveyPointName(pna,i,j,k,l)) {
AliTRDtrack *pt = new AliTRDtrack(seed2,seed2.GetAlpha());
Int_t *indexes2 = seed2.GetIndexes();
- for (Int_t i = 0; i < AliTRDtrack::kNplane;i++) {
+ for (Int_t l = 0; l < AliTRDtrack::kNplane;++l) {
for (Int_t j = 0; j < AliTRDtrack::kNslice;j++) {
- pt->SetPIDsignals(seed2.GetPIDsignals(i,j),i,j);
+ pt->SetPIDsignals(seed2.GetPIDsignals(l,j),l,j);
}
- pt->SetPIDTimBin(seed2.GetPIDTimBin(i),i);
+ pt->SetPIDTimBin(seed2.GetPIDTimBin(l),l);
}
Int_t *indexes3 = pt->GetBackupIndexes();
- for (Int_t i = 0; i < 200;i++) {
- if (indexes2[i] == 0) {
+ for (Int_t l = 0; l < 200;++l) {
+ if (indexes2[l] == 0) {
break;
}
- indexes3[i] = indexes2[i];
+ indexes3[l] = indexes2[l];
}
FollowProlongation(*pt);
seed->UpdateTrackParams(pt,AliESDtrack::kTRDrefit);
fHRefit->Fill(5);
- for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
+ for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
- seed->SetTRDslice(pt->GetPIDsignals(i,j),i,j);
+ seed->SetTRDslice(pt->GetPIDsignals(l,j),l,j);
}
- seed->SetTRDTimBin(pt->GetPIDTimBin(i),i);
+ seed->SetTRDTimBin(pt->GetPIDTimBin(l),l);
}
}
// If not prolongation to TPC - propagate without update
fHRefit->Fill(5);
- AliTRDtrack *seed2 = new AliTRDtrack(*seed);
- seed2->ResetCovariance(5.0);
- AliTRDtrack *pt2 = new AliTRDtrack(*seed2,seed2->GetAlpha());
- delete seed2;
+ AliTRDtrack *seed2t = new AliTRDtrack(*seed);
+ seed2t->ResetCovariance(5.0);
+ AliTRDtrack *pt2 = new AliTRDtrack(*seed2t,seed2t->GetAlpha());
+ delete seed2t;
if (PropagateToX(*pt2,xTPC,fgkMaxStep)) {
seed->UpdateTrackParams(pt2,AliESDtrack::kTRDrefit);
fHRefit->Fill(6);
- for (Int_t i = 0; i < AliTRDtrack::kNplane; i++) {
+ for (Int_t l = 0; l < AliTRDtrack::kNplane; ++l) {
for (Int_t j = 0; j < AliTRDtrack::kNslice; j++) {
- seed->SetTRDslice(pt2->GetPIDsignals(i,j),i,j);
+ seed->SetTRDslice(pt2->GetPIDsignals(l,j),l,j);
}
- seed->SetTRDTimBin(pt2->GetPIDTimBin(i),i);
+ seed->SetTRDTimBin(pt2->GetPIDTimBin(l),l);
}
}
t.SetSampledEdx(TMath::Abs(cl->GetQ()/dxsample));
Double_t h01 = GetTiltFactor(cl);
Int_t det = cl->GetDetector();
- Int_t plane = fGeom->GetPlane(det);
+ Int_t pplane = fGeom->GetPlane(det);
if (t.GetX() > 345.0) {
t.SetNLast(t.GetNLast() + 1);
maxChi2 = t.GetPredictedChi2(cl,h01);
if (maxChi2 < 1e+10) {
- if (!t.UpdateMI(cl,maxChi2,index,h01,plane)) {
+ if (!t.UpdateMI(cl,maxChi2,index,h01,pplane)) {
// ????
}
else {
cseed[sLayer+jLayer].SetPadLength(padlength[sLayer+jLayer]);
cseed[sLayer+jLayer].SetX0(xcl[sLayer+jLayer]);
- for (Int_t iter = 0; iter < 2; iter++) {
+ for (Int_t jter = 0; jter < 2; jter++) {
//
// In iteration 0 we try only one pad-row
//
AliTRDseed tseed = cseed[sLayer+jLayer];
Float_t roadz = padlength[sLayer+jLayer] * 0.5;
- if (iter > 0) {
+ if (jter > 0) {
roadz = padlength[sLayer+jLayer];
}
Double_t dxlayer = layer.GetX() - xcl[sLayer+jLayer];
Double_t zexp = cl[sLayer+jLayer]->GetZ();
- if (iter > 0) {
+ if (jter > 0) {
// Try 2 pad-rows in second iteration
zexp = tseed.GetZref(0) + tseed.GetZref(1) * dxlayer;
if (zexp > cl[sLayer+jLayer]->GetZ()) {
if (index <= 0) {
continue;
}
- AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
+ AliTRDcluster *clu = (AliTRDcluster *) GetCluster(index);
tseed.SetIndexes(iTime,index);
- tseed.SetClusters(iTime,cl); // Register cluster
- tseed.SetX(iTime,dxlayer); // Register cluster
- tseed.SetY(iTime,cl->GetY()); // Register cluster
- tseed.SetZ(iTime,cl->GetZ()); // Register cluster
+ tseed.SetClusters(iTime,clu); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,clu->GetY()); // Register cluster
+ tseed.SetZ(iTime,clu->GetZ()); // Register cluster
}
Float_t tquality = (18.0 - tseed.GetN2()) / 2.0 + TMath::Abs(dangle) / 0.1
+ TMath::Abs(tseed.GetYfit(0) - tseed.GetYref(0)) / 0.2
+ 2.0 * TMath::Abs(tseed.GetMeanz() - tseed.GetZref(0)) / padlength[jLayer];
- if ((iter == 0) && tseed.IsOK()) {
+ if ((jter == 0) && tseed.IsOK()) {
cseed[sLayer+jLayer] = tseed;
quality = tquality;
if (tquality < 5) {
cseed[sLayer+jLayer] = tseed;
}
- } // Loop: iter
+ } // Loop: jter
if (!cseed[sLayer+jLayer].IsOK()) {
isOK = kFALSE;
Float_t zexp = cseed[jLayer].GetZref(0);
Double_t zroad = padlength[jLayer] * 0.5 + 1.0;
- for (Int_t iter = 0; iter < 2; iter++) {
+ for (Int_t jter = 0; jter < 2; jter++) {
AliTRDseed tseed = cseed[jLayer];
Float_t quality = 10000.0;
if (index <= 0) {
continue;
}
- AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
+ AliTRDcluster *clu = (AliTRDcluster *) GetCluster(index);
tseed.SetIndexes(iTime,index);
- tseed.SetClusters(iTime,cl); // Register cluster
- tseed.SetX(iTime,dxlayer); // Register cluster
- tseed.SetY(iTime,cl->GetY()); // Register cluster
- tseed.SetZ(iTime,cl->GetZ()); // Register cluster
+ tseed.SetClusters(iTime,clu); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,clu->GetY()); // Register cluster
+ tseed.SetZ(iTime,clu->GetZ()); // Register cluster
}
tseed.Update();
zroad *= 2.0;
- } // Loop: iter
+ } // Loop: jter
if ( cseed[jLayer].IsOK()) {
cseed[jLayer].CookLabels();
Float_t lastchi2 = 10000.0;
Float_t chi2 = 1000.0;
- for (Int_t iter = 0; iter < 4; iter++) {
+ for (Int_t jter = 0; jter < 4; jter++) {
// Sort tracklets according "quality", try to "improve" 4 worst
Float_t sumquality = 0.0;
}
lastquality = sumquality;
lastchi2 = chi2;
- if (iter > 0) {
+ if (jter > 0) {
for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
cseed[jLayer] = bseed[jLayer];
}
if (index <= 0) {
continue;
}
- AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
+ AliTRDcluster *clu = (AliTRDcluster *) GetCluster(index);
tseed.SetIndexes(iTime,index);
- tseed.SetClusters(iTime,cl); // Register cluster
- tseed.SetX(iTime,dxlayer); // Register cluster
- tseed.SetY(iTime,cl->GetY()); // Register cluster
- tseed.SetZ(iTime,cl->GetZ()); // Register cluster
+ tseed.SetClusters(iTime,clu); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,clu->GetY()); // Register cluster
+ tseed.SetZ(iTime,clu->GetZ()); // Register cluster
}
chi2 = AliTRDseed::FitRiemanTilt(bseed,kTRUE);
- } // Loop: iter
+ } // Loop: jter
nclusters = 0;
nlayers = 0;
signedseed[i] = kFALSE;
}
- for (Int_t iter = 0; iter < 5; iter++) {
+ for (Int_t jter = 0; jter < 5; jter++) {
for (Int_t iseed = 0; iseed < registered; iseed++) {
continue;
}
- if (iter == 0) {
+ if (jter == 0) {
if (nlayers < 6) {
continue;
}
}
}
- if (iter == 1) {
+ if (jter == 1) {
if (nlayers < findable) {
continue;
}
}
}
- if (iter == 2) {
+ if (jter == 2) {
if ((nlayers == findable) ||
(nlayers == 6)) {
continue;
}
}
- if (iter == 3) {
+ if (jter == 3) {
if (TMath::Log(0.000000001+seedquality2[index]) < -5.0) {
continue;
}
}
- if (iter == 4) {
+ if (jter == 4) {
if (TMath::Log(0.000000001+seedquality2[index]) - nused/(nlayers-3.0) < -15.0) {
continue;
}
esdtrack.UpdateTrackParams(track,AliESDtrack::kTRDout);
esdtrack.SetLabel(label);
esd->AddTrack(&esdtrack);
- TTreeSRedirector &cstream = *fDebugStreamer;
if (AliTRDReconstructor::StreamLevel() > 0) {
cstream << "Tracks"
<< "EventNrInFile=" << eventNrInFile
if (AliTRDReconstructor::StreamLevel() > 0) {
cstream << "Seeds2"
- << "Iter=" << iter
+ << "Iter=" << jter
<< "Track.=" << track
<< "Like=" << seedquality[index]
<< "LikeF=" << seedquality2[index]
} // Loop: iseed
- } // Loop: iter
+ } // Loop: jter
} // End of loop over sectors
//
// Update best hypothesy if better chi2 according tracklet position and angle
//
- Double_t sy2 = smean[iter] + track->GetSigmaY2();
+ sy2 = smean[iter] + track->GetSigmaY2();
Double_t sa2 = sangle[iter] + track->GetSigmaSnp2(); // track->fCee;
Double_t say = track->GetSigmaSnpY(); // track->fCey;
// try attaching clusters to tracklets
Int_t nUsedCl = 0;
- Int_t nlayers = 0;
+ Int_t mlayers = 0;
for(int iLayer=0; iLayer<kNSeedPlanes; iLayer++){
Int_t jLayer = planes[iLayer];
if(!cseed[jLayer].AttachClustersIter(stack[jLayer], 5., kFALSE, c[iLayer])) continue;
nUsedCl += cseed[jLayer].GetNUsed();
if(nUsedCl > 25) break;
- nlayers++;
+ mlayers++;
}
- if(nlayers < kNSeedPlanes){
- //AliInfo(Form("Failed updating all seeds %d [%d].", nlayers, kNSeedPlanes));
+ if(mlayers < kNSeedPlanes){
+ //AliInfo(Form("Failed updating all seeds %d [%d].", mlayers, kNSeedPlanes));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
// fit extrapolated seed
if ((jLayer == 0) && !(cseed[1].IsOK())) continue;
if ((jLayer == 5) && !(cseed[4].IsOK())) continue;
- AliTRDseedV1 tseed = cseed[jLayer];
- if(!tseed.AttachClustersIter(chamber, 1000.)) continue;
- cseed[jLayer] = tseed;
+ AliTRDseedV1 pseed = cseed[jLayer];
+ if(!pseed.AttachClustersIter(chamber, 1000.)) continue;
+ cseed[jLayer] = pseed;
nusedf += cseed[jLayer].GetNUsed(); // debug value
FitTiltedRieman(cseed, kTRUE);
}
// fit full track and cook likelihoods
// Double_t curv = FitRieman(&cseed[0], chi2);
- // Double_t chi2ZF = chi2[0] / TMath::Max((nlayers - 3.), 1.);
- // Double_t chi2RF = chi2[1] / TMath::Max((nlayers - 3.), 1.);
+ // Double_t chi2ZF = chi2[0] / TMath::Max((mlayers - 3.), 1.);
+ // Double_t chi2RF = chi2[1] / TMath::Max((mlayers - 3.), 1.);
// do the final track fitting (Once with vertex constraint and once without vertex constraint)
Double_t chi2Vals[3];
chi2Vals[0] = FitTiltedRieman(&cseed[0], kFALSE);
chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ());
- chi2Vals[2] = GetChi2Z(&cseed[0]) / TMath::Max((nlayers - 3.), 1.);
+ chi2Vals[2] = GetChi2Z(&cseed[0]) / TMath::Max((mlayers - 3.), 1.);
// Chi2 definitions in testing stage
//chi2Vals[2] = GetChi2ZTest(&cseed[0]);
fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
<< "CandidateNumber=" << candidateNumber
<< "Chi2TR=" << chi2Vals[0]
<< "Chi2TC=" << chi2Vals[1]
- << "Nlayers=" << nlayers
+ << "Nlayers=" << mlayers
<< "NUsedS=" << nUsedCl
<< "NUsed=" << nusedf
<< "Like=" << like
Double_t pt = paramOut->Pt();
Double_t signal = 0;
- for(Int_t i=0; i<6; i++)
- signal += track->GetTRDslice(i, -1);
+ for(Int_t k=0; k<6; ++k)
+ signal += track->GetTRDslice(k, -1);
signal /= 6;
fSignalPtSum[idx]->Fill(pt, signal);
- for(Int_t i=0; i<AliPID::kSPECIES; i++) {
+ for(Int_t k=0; k<AliPID::kSPECIES; ++k) {
- Double_t lq = track->GetTRDpid(i);
- fProb[AliPID::kSPECIES*idx+i]->Fill(lq);
- if (lq > 0.8) fSignalPtType[AliPID::kSPECIES*idx+i]->Fill(pt, signal);
+ Double_t lq = track->GetTRDpid(k);
+ fProb[AliPID::kSPECIES*idx+k]->Fill(lq);
+ if (lq > 0.8) fSignalPtType[AliPID::kSPECIES*idx+k]->Fill(pt, signal);
}
}
Int_t pdg = (charge == 0)? -11 : 11;
for(Int_t k=0; k<knSteps; k++) fInSample[fnKFtracks][k] = 0;
- vec[fnKFtracks] = CreateVector(track);
- tracks[fnKFtracks] = new AliKFParticle(*track, pdg);
+ fVec[fnKFtracks] = CreateVector(track);
+ fTracks[fnKFtracks] = new AliKFParticle(*track, pdg);
fSM[fnKFtracks] = AliTRDqaAT::GetSector(paramOut->GetAlpha());
fnKFtracks++;
if (!fInSample[i][k]) continue;
for(Int_t j=i+1; j<fnKFtracks; j++) {
if (!fInSample[j][k]) continue;
- AliKFParticle jpsi(*(tracks[i]), *(tracks[j]));
- TLorentzVector jpsiVec = (*(vec[i])) + (*vec[j]);
+ AliKFParticle jpsi(*(fTracks[i]), *(fTracks[j]));
+ TLorentzVector jpsiVec = (*(fVec[i])) + (*fVec[j]);
fInvMass[k]->Fill(jpsi.GetMass());
fInvMassVec[k]->Fill(jpsiVec.M());
fInvMassDiff[k]->Fill(jpsiVec.M() - jpsi.GetMass());
TH2D *fPtAngle[knSteps];
// tracks
- AliKFParticle *tracks[1000];
- TLorentzVector *vec[1000];
+ AliKFParticle *fTracks[1000];
+ TLorentzVector *fVec[1000];
Int_t fInSample[1000][knSteps];
Int_t fSM[1000];
Int_t fnKFtracks; //[2];