: AliAnalysisTaskSE(name)
,fTrackType(0)
,fStandAlone(0)
+ ,fLow(0)
+ ,fHigh(100)
,fFieldOn(kTRUE)
,fHists(0)
,fHistRECpt(0)
,fEta(0)
+ ,fEtaWidth(0)
+ ,fPhiWidth(0)
+ ,fDcaWidth(0)
+ ,fPtWidth(0)
,fEtaPhi(0)
,fEtaPt(0)
,fQPt(0)
,fDca(0)
+ ,fDcaZ(0)
,fqRec(0)
,fSigmaPtHist(0)
,fVx(0)
,fVy(0)
,fVz(0)
- ,fVertexX(0)
- ,fVertexY(0)
- ,fVertexZ(0)
,fNVertexSPD(0)
,fNVertexTracks(0)
,fRecDcaPosPhi(0)
{
// Constructor
+ for(Int_t i = 0;i<4;++i){
+ fVertexX[i]=0;
+ fVertexY[i]=0;
+ fVertexZ[i]=0;
+ }
+
for(Int_t i = 0;i<18;++i){
fRecPtTpcSector[i] = 0;
fRecEtaTpcSector[i] = 0;
fDcaSigmaNeg[i] =0;
}
+ for(Int_t i = 0;i< 3;i++){
+ for(Int_t j = 0;j< 2;j++){
+ fEtaBinPt[i][j]=0;
+ fPhiBinPt[i][j]=0;
+ fDcaBinPt[i][j]=0;
+ fEtaPhiBinPt[i][j]=0;
+ }
+ }
+
DefineOutput(1, TList::Class());
fEta = new TH1F("fEta",
" #eta",
200, -2., 2.);
+ fEtaWidth = new TH1F("fEtaWidth",
+ " #eta",
+ 200, -2., 2.);
+ fPhiWidth = new TH1F("fPhiWidth",
+ " #phi",
+ 200, 0., 2*TMath::Pi());
+ fDcaWidth = new TH1F("fDcaWidth",
+ "dca",
+ 200, -range*(1+Int_t(fTrackType/2)*9), range*(1+Int_t(fTrackType/2)*9));
+ fPtWidth = new TH1F("fPtWidth",
+ "p_{T}",
+ 200, 0., pt);
fEtavPt = new TH2F("fEtavPt",
" #eta -p_{T}",
200, -2., 2.,
fITSlayerPhi = new TH2F("fITSlayerPhi",
"fITSlayerPhi",
8, -1.5, 6.5, 200, 0,2*TMath::Pi());
-
fEtaPhi = new TH2F("fEtaPhi",
" #eta - #phi",
200, -2., 2., 128, 0., 2. * TMath::Pi());
-
fThetaRec = new TH1F("fThetaRec",
" #theta",
180, 0., TMath::Pi());
180, 0., 2*TMath::Pi());
fNumber = new TH1F("fNumber",
"number of tracks per event",
- 300, -0.5, 299.5);
+ 500, -5, 4995);
fNumberAfterCut = new TH1F("fNumberAfterCut",
"number of tracks per event after cuts",
- 300, -0.5, 299.5);
+ 500, -5, 4995);
fVx = new TH1F("fVx",
"X of first track point",
100, -1., 1.);
fVz = new TH1F("fVz",
"Z of first track point",
200, -50., 50.);
- fVertexX = new TH1F("fVertexX",
- "X of vertex",
- 100, -1., 1.);
- fVertexY = new TH1F("fVertexY",
- "Y of vertex",
- 100, -1., 1.);
- fVertexZ = new TH1F("fVertexZ",
- "Z of vertex",
- 200, -50., 50.);
fNVertexSPD = new TH1F("fNVertexSPD",
"Number of SPD vertices",
10, -0.5, 9.5);
" dca ",
200, -range*(1+Int_t(fTrackType/2)*9), range*(1+Int_t(fTrackType/2)*9));
+ fDcaZ = new TH1F("fDcaZ", "fDcaZ ",200, -3, 3);// limits fitting those of track cuts
+
fqRec = new TH1F("fqRec",
" charge all reconstructed particle",
200, -4., 8.);
-
+ TString lable[4]={"", "SPD", "Track", "TPC"};
+ for(Int_t i=0;i<4;i++){
+ fVertexX[i] = new TH1F(Form("fVertexX%s",lable[i].Data()),
+ Form("fVertexX%s",lable[i].Data()),
+ 100, -1., 1.);
+ fVertexY[i] = new TH1F(Form("fVertexY%s",lable[i].Data()),
+ Form("fVertexY%s",lable[i].Data()),
+ 100, -1., 1.);
+ if(i==1 || i==2){
+ fVertexZ[i] = new TH1F(Form("fVertexZ%s",lable[i].Data()),
+ Form("fVertexZ%s",lable[i].Data()),
+ 200, -5., 5.);
+ }
+ else{
+ fVertexZ[i] = new TH1F(Form("fVertexZ%s",lable[i].Data()),
+ Form("fVertexZ%s",lable[i].Data()),
+ 200, -50., 50.);
+ }
+ }
//------------
for(Int_t ITSlayer_case=0;ITSlayer_case<7;ITSlayer_case++){
fRecEtaNegLadder[i]->GetXaxis()->SetTitle("#eta");
}
- Double_t vzmax = 15;
+ Double_t vzmax = 15.;
fRecPtPosVz = new TH2F("fRecPtPosVz",
"p_{T} distribution vs Vz()",
// fRecDcaPhiPtNegEtaNeg->GetYaxis()->SetTitle("#phi (rad.)");
// fRecDcaPhiPtNegEtaNeg->GetXaxis()->SetTitle("p_{T} (GeV/c)");
-
+ TString charge[2];
+ charge[0]="Pos";
+ charge[1]="Neg";
+
+ for(Int_t i=0;i<3;i++){
+ for(Int_t j=0;j<2;j++){
+ fEtaBinPt[i][j] = new TH1F(Form("fEtaBinPt%d%s", i, charge[j].Data()),
+ "eta",
+ 200, -2., 2.);
+ fPhiBinPt[i][j] = new TH1F(Form("fPhiBinPt%d%s", i,charge[j].Data() ),
+ "phi",
+ 181, 0, 2*TMath::Pi());
+ fDcaBinPt[i][j] = new TH1F(Form("fDcaBinPt%d%s", i, charge[j].Data()),
+ "DCA",
+ 200,-range*(1+Int_t(fTrackType/2)*9),
+ range*(1+Int_t(fTrackType/2)*9) );
+ fEtaPhiBinPt[i][j]= new TH2F(Form("fEtaPhiBinPt%d%s", i, charge[j].Data()),
+ "eta-phi",
+ 200, -2., 2., 200, 0.,2*TMath::Pi());
+ }
+ }
fHists->SetOwner();
fHists->Add(fHistRECpt);
fHists->Add(fEta);
+ fHists->Add(fEtaWidth);
+ fHists->Add(fPhiWidth);
+ fHists->Add(fDcaWidth);
+ fHists->Add(fPtWidth);
fHists->Add(fEtavPt);
fHists->Add(fPhivPt);
fHists->Add(fCompareTPCparam);
fHists->Add(fVx);
fHists->Add(fVy);
fHists->Add(fVz);
- fHists->Add(fVertexX);
- fHists->Add(fVertexY);
- fHists->Add(fVertexZ);
fHists->Add(fNVertexSPD);
fHists->Add(fNVertexTracks);
fHists->Add(fEtaPt);
fHists->Add(fQPt);
fHists->Add(fDca);
+ fHists->Add(fDcaZ);
fHists->Add(fDeltaPhiAll);
fHists->Add(fDeltaPhiLeading);
fHists->Add(fRecDPosEta);
fHists->Add(fRecDNegEta);
-
+ for(Int_t i=0;i<4;i++){
+ fHists->Add(fVertexX[i]);
+ fHists->Add(fVertexY[i]);
+ fHists->Add(fVertexZ[i]);
+ }
for(Int_t i=0;i<18;i++){
fHists->Add(fRecPtTpcSector[i]);
fHists->Add(fRecEtaTpcSector[i]);
// fHists->Add(fRecDcaPhiPtNegEtaPos);
// fHists->Add(fRecDcaPhiPtNegEtaNeg);
-
-
+ for(Int_t i=0;i<3;i++){
+ for(Int_t j=0;j<2;j++){
+ fHists->Add(fEtaBinPt[i][j]);
+ fHists->Add(fPhiBinPt[i][j]);
+ fHists->Add(fDcaBinPt[i][j]);
+ fHists->Add(fEtaPhiBinPt[i][j]);
+ }
+ }
// for (Int_t i=0; i<fHists->GetEntries(); ++i) {
// }
TH1::AddDirectory(oldStatus);
+ PostData(1, fHists);
+
}
//__________________________________________________________
if(Entry()==0){
- AliESDEvent* esd =
dynamic_cast<AliESDEvent*>(event);
+ AliESDEvent* esd =
static_cast<AliESDEvent*>(event);
if(esd){
Printf("We are reading from ESD");
}
//check vertices
- AliESDEvent* esd =
dynamic_cast<AliESDEvent*>(event);
+ AliESDEvent* esd =
static_cast<AliESDEvent*>(event);
Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex
Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();
fNVertexSPD->Fill(nPileSPDVertices);
fNVertexTracks->Fill(nPileTrkVertices);
-
//check primary vertex
+ Float_t vx = 0;
+ Float_t vy = 0;
+ Float_t vz = 0;
+
+ //primary vertex: contribution from different vertexers
const AliVVertex* vertex = event->GetPrimaryVertex();
- if(vertex->GetNContributors()==0) return;
- Float_t vx = vertex->GetX();
- Float_t vy = vertex->GetY();
- Float_t vz = vertex->GetZ();
+ if(!vertex) return;
+ vx = vertex->GetX();
+ vy = vertex->GetY();
+ vz = vertex->GetZ();
+ if(vertex->GetNContributors()>0){
+ fVertexX[0]->Fill(vx);
+ fVertexY[0]->Fill(vy);
+ fVertexZ[0]->Fill(vz);
+ }
+
+
- fVertexX->Fill(vx);
- fVertexY->Fill(vy);
- fVertexZ->Fill(vz);
+ const AliVVertex* vertexSPD = esd->GetPrimaryVertexSPD();
+ if(vertexSPD){
+ if(vertexSPD->GetNContributors()>0){
+ fVertexX[1]->Fill(vertexSPD->GetX());
+ fVertexY[1]->Fill(vertexSPD->GetX());
+ fVertexZ[1]->Fill(vertexSPD->GetX());
+ }
+ }
+
+ const AliVVertex* vertexTrack = esd->GetPrimaryVertexTracks();
+ if(vertexTrack){
+ if(vertexTrack->GetNContributors()>0){
+ fVertexX[2]->Fill(vertexTrack->GetX());
+ fVertexY[2]->Fill(vertexTrack->GetX());
+ fVertexZ[2]->Fill(vertexTrack->GetX());
+ }
+ }
+ const AliVVertex* vertexTPC = esd->GetPrimaryVertexTPC();
+ if(vertexTPC){
+ if(vertexTPC->GetNContributors()>0){
+ fVertexX[3]->Fill(vertexTPC->GetX());
+ fVertexY[3]->Fill(vertexTPC->GetX());
+ fVertexZ[3]->Fill(vertexTPC->GetX());
+ }
+ }
+
+ //cuts on general vertex
+ if(vertex->GetNContributors()<1) return;
if (TMath::Abs(vz) > 10.) return;
fNumber->Fill(event->GetNumberOfTracks());
AliESDtrack *tpcP = 0x0;
Int_t fNTracksAccepted=0;
+ const Int_t arrSize = event->GetNumberOfTracks();
+ Float_t * phiArray = new Float_t[arrSize];
+ Float_t * etaArray = new Float_t[arrSize];
+ Float_t * ptArray = new Float_t[arrSize];
+ Float_t * dcaArray = new Float_t[arrSize];
+ Int_t * chargeArray = new Int_t [arrSize];
+ Bool_t * acceptedArray = new Bool_t [arrSize];
+
+ for (Int_t i = 0; i < event->GetNumberOfTracks(); i++) {
+ phiArray[i] = 0.;
+ etaArray[i] = 0.;
+ ptArray[i] = 0.;
+ dcaArray[i] = 0.;
+ chargeArray[i] = 0;
+ acceptedArray[i]= kFALSE;
+
+ }
+
+
for (Int_t iTrack = 0; iTrack < event->GetNumberOfTracks(); iTrack++) {
}
AliVParticle *track = event->GetTrack(iTrack);
- AliESDtrack *esdtrack =
dynamic_cast<AliESDtrack*>(track);
+ AliESDtrack *esdtrack =
static_cast<AliESDtrack*>(track);
esdtrack->PropagateToDCA(event->GetPrimaryVertex(),
event->GetMagneticField(), 10000.);
//__________
// run Task for global tracks or ITS tracks or TPC tracks
const AliExternalTrackParam *tpcPin = 0x0;
- Double_t phiIn=0;
+ Double_t phiIn=0.;
if(fTrackType==0){
//Fill all histograms with global tracks
tpcP = esdtrack;
- phiIn = tpcP->Phi();
if (!tpcP) continue;
if (!fCuts->AcceptTrack(tpcP)) continue;
+ phiIn = tpcP->Phi();
}
else if(fTrackType==1){
//Fill all histograms with ITS tracks
if(fStandAlone==kTRUE) {
if(!(tpcP->GetStatus()&AliESDtrack::kITSpureSA))continue;
}
+ else if(fStandAlone==kFALSE){
+ if(tpcP->GetStatus()&AliESDtrack::kITSpureSA)continue;
+ }
}
else if(fTrackType==2){
//Fill all histograms with TPC track information
if (!tpcPin) continue;
phiIn=tpcPin->Phi();
- tpcP = AliESDtrackCuts::GetTPCOnlyTrack(
dynamic_cast<AliESDEvent*>(event),esdtrack->GetID());
+ tpcP = AliESDtrackCuts::GetTPCOnlyTrack(
static_cast<AliESDEvent*>(event),esdtrack->GetID());
if (!tpcP) continue;
if (!fCuts->AcceptTrack(tpcP)) continue;
if(tpcP->GetNcls(1)>160)continue;//jacek's track cut
fNTracksAccepted++;
+ phiArray[iTrack] = phiIn;
+ etaArray[iTrack] = tpcP->Eta();
+ ptArray[iTrack] = tpcP->Pt();
+ chargeArray[iTrack] = tpcP->Charge();
+ acceptedArray[iTrack]= kTRUE;
+
if(tpcP->E()>leadingEnergy){
leadingTrack=iTrack;
fHistRECpt->Fill(tpcP->Pt());
fEta->Fill(tpcP->Eta());
fEtavPt->Fill(tpcP->Eta(), TMath::Log(tpcP->Pt()));
- fPhivPt->Fill(tpcP->Phi(), TMath::Log(tpcP->Pt()));
+ fPhivPt->Fill(phiIn, TMath::Log(tpcP->Pt()));
fEtaPhi->Fill(tpcP->Eta(), phiIn);
fThetaRec->Fill(tpcP->Theta());
fPhiRec->Fill(phiIn);
fEtaPt->Fill(tpcP->Eta()/tpcP->Pt());
fQPt->Fill(tpcP->Charge()/tpcP->Pt());
fDca->Fill(fSignedDca);
+ dcaArray[iTrack]=fSignedDca;
fRecQPtPhi->Fill(tpcP->Charge()/tpcP->Pt(), phiIn);
Float_t fXY = 0.;
tpcP->GetImpactParameters(fXY,fZ);
fDiffDcaD->Fill(fSignedDca+fXY);
-
+ fDcaZ->Fill(fZ);
+
if(fTrackType==2) fCompareTPCparam->Fill(fZ,tpcPin->GetTgl());
if(fTrackType!=2){//for global and ITS tracks
// if(LeadingTrack==iTrack2) continue;
// AliVParticle *track2 = event->GetTrack(iTrack2);
-// AliESDtrack* esdtrack2 =
dynamic_cast<AliESDtrack*>(track2);
+// AliESDtrack* esdtrack2 =
static_cast<AliESDtrack*>(track2);
// if (!track2) {
// Printf("ERROR: Could not receive track %d", iTrack);
// continue;
}//first track loop
fNumberAfterCut->Fill(fNTracksAccepted);
+
+ //second track loop
+
+ for (Int_t iT = 0; iT < event->GetNumberOfTracks(); iT++) {
+ if(acceptedArray[iT]){
+ if(ptArray[iT]>0.2 && ptArray[iT]<1. ){
+ fEtaBinPt[0][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT]);
+ fDcaBinPt[0][Bool_t(chargeArray[iT]>0)]->Fill(dcaArray[iT]);
+ fPhiBinPt[0][Bool_t(chargeArray[iT]>0)]->Fill(phiArray[iT]);
+ fEtaPhiBinPt[0][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT], phiArray[iT]);
+ }
+ else if(ptArray[iT]>1. && ptArray[iT]<5.){
+ fEtaBinPt[1][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT]);
+ fDcaBinPt[1][Bool_t(chargeArray[iT]>0)]->Fill(dcaArray[iT]);
+ fPhiBinPt[1][Bool_t(chargeArray[iT]>0)]->Fill(phiArray[iT]);
+ fEtaPhiBinPt[1][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT], phiArray[iT]);
+ }
+ else if (ptArray[iT]>5.){
+ fEtaBinPt[2][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT]);
+ fDcaBinPt[2][Bool_t(chargeArray[iT]>0)]->Fill(dcaArray[iT]);
+ fPhiBinPt[2][Bool_t(chargeArray[iT]>0)]->Fill(phiArray[iT]);
+ fEtaPhiBinPt[2][Bool_t(chargeArray[iT]>0)]->Fill(etaArray[iT], phiArray[iT]);
+ }
+
+ if(fNTracksAccepted>=fLow&&fNTracksAccepted<=fHigh){
+ fEtaWidth->Fill(etaArray[iT]);
+ fPhiWidth->Fill(phiArray[iT]);
+ fDcaWidth->Fill(dcaArray[iT]);
+ fPtWidth->Fill(ptArray[iT]);
+ }
+ }
+ }
+
//prevent mem leak for TPConly track
if(fTrackType==2&&tpcP){
delete tpcP;
tpcP = 0;
}
-
+ if(phiArray){
+ delete[] phiArray;
+ phiArray=0;
+ }
+
+ if(etaArray){
+ delete[] etaArray;
+ etaArray=0;
+ }
+
+ if(dcaArray){
+ delete[] dcaArray;
+ dcaArray=0;
+ }
+
+ if(ptArray){
+ delete[] ptArray;
+ ptArray=0;
+ }
+
+ if(chargeArray){
+ delete[] chargeArray;
+ chargeArray=0;
+ }
+
+ if(acceptedArray){
+ delete[] acceptedArray;
+ acceptedArray=0;
+ }
+
// Post output data.
// PostData(1, fHistPt);
PostData(1, fHists);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff