fHistPhi(0),\r
fHistV0M(0),\r
fESDtrackCuts(0),\r
- fCentralityEstimator("VOM"),\r
+ fCentralityEstimator("V0M"),\r
fCentralityPercentileMin(0.), \r
fCentralityPercentileMax(5.),\r
fUseOfflineTrigger(kFALSE),\r
\r
//Centrality stuff (centrality in AOD header)\r
AliAODHeader *aodHeader = gAOD->GetHeader();\r
- Float_t fCentrality = aodHeader->GetCentralityP()->GetCentralityPercentile("V0M");\r
- //cout<< aodHeader->GetCentralityP()->GetCentralityPercentile("V0M")<<" "<<aodHeader->GetCentralityP()->GetCentralityPercentile("CL1")<<" "<<aodHeader->GetCentralityP()->GetCentralityPercentile("TRK")<<endl;\r
+ Float_t fCentrality = aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());\r
+ // cout<<fCentralityEstimator.Data()<<" = "<<fCentrality<<" , others are V0M = "\r
+ // << aodHeader->GetCentralityP()->GetCentralityPercentile("V0M")\r
+ // <<" FMD = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("FMD")\r
+ // <<" TRK = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("TRK")\r
+ // <<" TKL = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("TKL")\r
+ // <<" CL0 ="<<aodHeader->GetCentralityP()->GetCentralityPercentile("CL0")\r
+ // <<" CL1 ="<<aodHeader->GetCentralityP()->GetCentralityPercentile("CL1")\r
+ // <<" V0MvsFMD = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("V0MvsFMD")\r
+ // <<" TKLvsV0M = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("TKLvsV0M")\r
+ // <<" ZEMvsZDC = "<<aodHeader->GetCentralityP()->GetCentralityPercentile("ZEMvsZDC")\r
+ // <<endl;\r
+\r
// take only events inside centrality class\r
if(fCentrality > fCentralityPercentileMin && fCentrality < fCentralityPercentileMax){\r
\r
} //track loop\r
}//MC analysis\r
\r
-\r
- // calculate balance function\r
- fBalance->CalculateBalance(array);\r
-\r
-\r
-\r
// shuffle charges\r
random_shuffle( chargeVectorShuffle.begin(), chargeVectorShuffle.end() );\r
- \r
- for(Int_t iArray = 0; iArray < array->GetEntries(); iArray++){\r
-\r
- // setting the charge in this way only possible for AOD tracks \r
- // --> shuffling only for AODs up to now\r
- if(gAnalysisLevel == "AOD") {\r
- AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(array->At(iArray));\r
- if (!aodTrack) {\r
- Printf("ERROR: Could not receive track %d", iArray);\r
- continue;\r
- }\r
\r
- aodTrack->SetCharge(chargeVectorShuffle.at(iArray));\r
- }\r
- }\r
- \r
- //calculate shuffled balance function\r
- fShuffledBalance->CalculateBalance(array);\r
-\r
- // set back the charges!\r
- for(Int_t iArray = 0; iArray < array->GetEntries(); iArray++){\r
-\r
- // setting the charge in this way only possible for AOD tracks \r
- // --> shuffling only for AODs up to now\r
- if(gAnalysisLevel == "AOD") {\r
- AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(array->At(iArray));\r
- if (!aodTrack) {\r
- Printf("ERROR: Could not receive track %d", iArray);\r
- continue;\r
- }\r
-\r
- aodTrack->SetCharge(chargeVector.at(iArray));\r
- }\r
- }\r
+ // calculate balance function (also for shuffled events)\r
+ fBalance->CalculateBalance(array,chargeVector);\r
+ fShuffledBalance->CalculateBalance(array,chargeVectorShuffle);\r
\r
\r
delete array;\r
}
//____________________________________________________________________//
-void AliBalance::CalculateBalance(TObjArray *gTrackArray) {
+void AliBalance::CalculateBalance(TObjArray *gTrackArray, vector<Int_t> chargeVector) {
// Calculates the balance function
fAnalyzedEvents++;
Int_t i = 0 , j = 0;
track = dynamic_cast<AliMCParticle *>(gTrackArray->At(i));
if(track) {
- Short_t charge = track->Charge();
+ Short_t charge = chargeVector.at(i);
Double_t pseudorapidity = track->Eta();
Double_t rapidity = track->Y();
Double_t phi = track->Phi() * TMath::RadToDeg();
}//track object valid
else continue;
}
- //Printf("Np: %lf - Nn: %lf",fNp,fNn);
+ //Printf("Np: %lf - Nn: %lf",fNp[0],fNn[0]);
Double_t dy = 0., deta = 0.;
Double_t qLong = 0., qOut = 0., qSide = 0., qInv = 0.;
if(track1) {
- charge1 = track1->Charge();
+ charge1 = chargeVector.at(i);;
p1 = track1->P();
pX1 = track1->Px();
pY1 = track1->Py();
track2 = dynamic_cast<AliMCParticle *>(gTrackArray->At(j));
if(track2) {
- charge2 = track2->Charge();
+ charge2 = chargeVector.at(j);
p2 = track2->P();
pX2 = track2->Px();
pY2 = track2->Py();
Double_t GetNnp(Int_t analysisType, Int_t p2) const {
return 1.0*fNnp[analysisType][p2]; }
- void CalculateBalance(TObjArray *gTrackArray);
+ void CalculateBalance(TObjArray *gTrackArray, vector<Int_t> chargeVector);
Double_t GetBalance(Int_t a, Int_t p2);
Double_t GetError(Int_t a, Int_t p2);
//=============================================//\r
const char* centralityEstimator = "V0M";\r
+//const char* centralityEstimator = "CL1";\r
+//const char* centralityEstimator = "TRK";\r
//=============================================//\r
\r
//_________________________________________________________//\r
if(analysisType == "ESD") {\r
AliESDtrackCuts *trackCuts = GetTrackCutsObject();\r
taskBF->SetAnalysisCutObject(trackCuts);\r
- taskBF->SetCentralityEstimator(centralityEstimator);\r
\r
// offline trigger selection (AliVEvent.h)\r
// taskBF->UseOfflineTrigger(); // NOT used (selection is done with the AliAnalysisTaskSE::SelectCollisionCandidates()) \r
taskBF->SetExtraDCACutsAOD(DCAxy,DCAz);\r
}\r
\r
+ // centrality estimator (default = V0M)\r
+ taskBF->SetCentralityEstimator(centralityEstimator);\r
+\r
+\r
// vertex cut (x,y,z)\r
taskBF->SetVertexDiamond(.3,.3,vertexZ);\r
\r
AliBalance *bf[10][7];
AliBalance *bfs[10][7];
- TH1F *gbf[10][7];
- TH1F *gbfs[10][7];
+ TH1D *gbf[10][7];
+ TH1D *gbfs[10][7];
TH1D *fHistP[7]; //N+
TH1D *fHistN[7]; //N-
TH1D *fHistPP[7]; //N++
TH1D *fHistNN[7]; //N--
+ TH1D *fHistPS[7]; //N+
+ TH1D *fHistNS[7]; //N-
+ TH1D *fHistPNS[7]; //N+-
+ TH1D *fHistNPS[7]; //N-+
+ TH1D *fHistPPS[7]; //N++
+ TH1D *fHistNNS[7]; //N--
+
while ( (key = (TKey*)nextkey())) {
list = (TList*)key->ReadObj();
gbf[iCanvas][a]->Draw("AP");
}
else{
- fHistPP[a]->Draw();
fHistPN[a]->SetLineColor(2);
- fHistPN[a]->Draw("same");
+ fHistPN[a]->Draw();
+ fHistPP[a]->SetLineColor(1);
+ fHistPP[a]->Draw("same");
fHistNP[a]->SetLineColor(4);
fHistNP[a]->Draw("same");
fHistNN[a]->SetLineColor(8);
// create the BF object
bfs[iCanvas][a] = new AliBalance();
- fHistP[a] = (TH1D*)list->FindObject(Form("fHistP%s_shuffle",gBFAnalysisType[a].Data()));
- fHistN[a] = (TH1D*)list->FindObject(Form("fHistP%s_shuffle",gBFAnalysisType[a].Data()));
- fHistPP[a] = (TH1D*)list->FindObject(Form("fHistPP%s_shuffle",gBFAnalysisType[a].Data()));
- fHistPN[a] = (TH1D*)list->FindObject(Form("fHistPN%s_shuffle",gBFAnalysisType[a].Data()));
- fHistNP[a] = (TH1D*)list->FindObject(Form("fHistNP%s_shuffle",gBFAnalysisType[a].Data()));
- fHistNN[a] = (TH1D*)list->FindObject(Form("fHistNN%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistPS[a] = (TH1D*)list->FindObject(Form("fHistP%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistNS[a] = (TH1D*)list->FindObject(Form("fHistP%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistPPS[a] = (TH1D*)list->FindObject(Form("fHistPP%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistPNS[a] = (TH1D*)list->FindObject(Form("fHistPN%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistNPS[a] = (TH1D*)list->FindObject(Form("fHistNP%s_shuffle",gBFAnalysisType[a].Data()));
+ fHistNNS[a] = (TH1D*)list->FindObject(Form("fHistNN%s_shuffle",gBFAnalysisType[a].Data()));
// set histograms in AliBalance object
- bfs[iCanvas][a]->SetHistNp(a, fHistP[a]);
- bfs[iCanvas][a]->SetHistNn(a, fHistN[a]);
- bfs[iCanvas][a]->SetHistNpp(a, fHistPP[a]);
- bfs[iCanvas][a]->SetHistNpn(a, fHistPN[a]);
- bfs[iCanvas][a]->SetHistNnp(a, fHistNP[a]);
- bfs[iCanvas][a]->SetHistNnn(a, fHistNN[a]);
-
- gbfs[iCanvas][a] = bf[iCanvas][a]->GetBalanceFunctionHistogram(a);
+ bfs[iCanvas][a]->SetHistNp(a, fHistPS[a]);
+ bfs[iCanvas][a]->SetHistNn(a, fHistNS[a]);
+ bfs[iCanvas][a]->SetHistNpp(a, fHistPPS[a]);
+ bfs[iCanvas][a]->SetHistNpn(a, fHistPNS[a]);
+ bfs[iCanvas][a]->SetHistNnp(a, fHistNPS[a]);
+ bfs[iCanvas][a]->SetHistNnn(a, fHistNNS[a]);
+
+ gbfs[iCanvas][a] = bfs[iCanvas][a]->GetBalanceFunctionHistogram(a);
gbfs[iCanvas][a]->SetName(Form("%s_BF_%s",listName.Data(),gBFAnalysisType[a].Data()));
cBFS[iCanvas]->cd(a+1);
gbfs[iCanvas][a]->SetMarkerStyle(20);
if(!bHistos){
- gbf[iCanvas][a]->Draw("AP");
+ gbfs[iCanvas][a]->Draw("AP");
}
else{
- fHistPP[a]->Draw();
- fHistPN[a]->SetLineColor(2);
- fHistPN[a]->Draw("same");
- fHistNP[a]->SetLineColor(4);
- fHistNP[a]->Draw("same");
- fHistNN[a]->SetLineColor(8);
- fHistNN[a]->Draw("same");
+ fHistPNS[a]->SetLineColor(2);
+ fHistPNS[a]->Draw();
+ fHistPPS[a]->SetLineColor(1);
+ fHistPPS[a]->Draw("same");
+ fHistNPS[a]->SetLineColor(4);
+ fHistNPS[a]->Draw("same");
+ fHistNNS[a]->SetLineColor(8);
+ fHistNNS[a]->Draw("same");
}
}
}
const bool bAOD = 1, // 1 = AOD ANALYSIS, 0 = ESD ANALYSIS\r
const bool bMCtruth = 0, // 1 = MCEvent handler is on (MC truth), 0 = MCEvent handler is off (MC reconstructed/real data)\r
const bool bMCphyssel = 0, // 1 = looking at MC truth or reconstructed, 0 = looking at real data\r
- const Long64_t nentries = 5000, // for local and proof mode, ignored in grid mode. Set to 1234567890 for all events.\r
+ const Long64_t nentries = 50000, // for local and proof mode, ignored in grid mode. Set to 1234567890 for all events.\r
const Long64_t firstentry = 0, // for local and proof mode, ignored in grid mode\r
- const char *proofdataset = "bunchPROOF.txt", // path to dataset on proof cluster, for proof analysis\r
+ TString proofdataset = "bunchPROOF", // path to dataset on proof cluster, for proof analysis\r
const char *proofcluster = "miweber@alice-caf.cern.ch", // which proof cluster to use in proof mode\r
const char *taskname = "BF_Syst_Test" // sets name of grid generated macros\r
)\r
AliAnalysisManager* mgr = new AliAnalysisManager(Form("%s%i",taskname,bunchN));\r
\r
// create the alien handler and attach it to the manager\r
- AliAnalysisGrid *plugin = CreateAlienHandler(bAOD,bunchN,Form("%s%i",taskname,bunchN), gridmode, proofcluster, proofdataset); \r
+ AliAnalysisGrid *plugin = CreateAlienHandler(bAOD,bunchN,Form("%s%i",taskname,bunchN), gridmode, proofcluster, Form("%s_%d.txt",proofdataset.Data(),bunchN)); \r
mgr->SetGridHandler(plugin);\r
\r
\r
\r
//Add the BF task (all centralities)\r
gROOT->LoadMacro("AddTaskBalanceCentralityTrain.C"); \r
- AliAnalysisTaskBF *task = AddTaskBalanceCentralityTrain(0,100,vZ[0],DCAxy[0],DCAz[0],ptMin[0],ptMax[0],etaMin[0],etaMax[0]);\r
+ //AliAnalysisTaskBF *task = AddTaskBalanceCentralityTrain(0,5,vZ[0],DCAxy[0],DCAz[0],ptMin[0],ptMax[0],etaMin[0],etaMax[0]);\r
+ \r
+ //Add the BFG task (different centralities)\r
+ for (Int_t i=binfirst; i<binlast+1; i++) {\r
+ Float_t lowCentralityBinEdge = centralityArray[i];\r
+ Float_t highCentralityBinEdge = centralityArray[i+1];\r
+ \r
+ // For systematic studies ( A train of centrality trains )\r
+ //for(Int_t j = 0; j < 1/*numberOfSyst*/; j++){\r
+ Int_t j = 0;\r
+ Printf("\nWagon for centrality bin %i: %.0f-%.0f (systematics %d)",i,lowCentralityBinEdge,highCentralityBinEdge,j);\r
+ AddTaskBalanceCentralityTrain(lowCentralityBinEdge,highCentralityBinEdge,vZ[j],DCAxy[j],DCAz[j],ptMin[j],ptMax[j],etaMin[j],etaMax[j]);\r
+ //}\r
+ } \r
\r
- // //Add the BFG task (different centralities)\r
- // for (Int_t i=binfirst; i<binlast+1; i++) {\r
- // Float_t lowCentralityBinEdge = centralityArray[i];\r
- // Float_t highCentralityBinEdge = centralityArray[i+1];\r
-\r
- // // For systematic studies ( A train of centrality trains )\r
- // for(Int_t j = 0; j < 1/*numberOfSyst*/; j++){\r
- // Printf("\nWagon for centrality bin %i: %.0f-%.0f (systematics %d)",i,lowCentralityBinEdge,highCentralityBinEdge,j);\r
- // AddTaskBalanceCentralityTrain(lowCentralityBinEdge,highCentralityBinEdge,vZ[j],DCAxy[j],DCAz[j],ptMin[j],ptMax[j],etaMin[j],etaMax[j]);\r
- // }\r
- // } \r
- \r
\r
+\r
// enable debug printouts\r
//mgr->SetDebugLevel(2);\r
//mgr->SetUseProgressBar(1,100);\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff