cmsListDir( const TObjString * firstdirname, const TDirectory * firstDir )
{
TObjArray * dirs = new TObjArray ;
dirs->AddLast(new TPair(firstdirname,firstDir)) ;
TList * keys ;
TKey * key ;
TH1 * histo ;
TIter nextDir(dirs) ;
TPair * pair ;
const TObjString * dirname ;
const TDirectory * dir ;
while (pair = (TPair *)nextDir())
{
dirname = (TObjString *)pair->Key() ;
dir = (TDirectory *)pair->Value() ;
keys = dir->GetListOfKeys() ;
TIter nextKey(keys) ;
while (key = (TKey *)nextKey())
{
obj = key->ReadObj() ;
if (obj->IsA()->InheritsFrom("TDirectory"))
{
dirs->AddLast(new TPair(new TObjString(dirname->String()+"/"+obj->GetName()),obj)) ;
}
else if (obj->IsA()->InheritsFrom("TH1"))
{
histo = (TH1 *)obj ;
std::cout
<<"Histo "<<dirname->String()<<"/"<<histo->GetName()
<<" has "<<histo->GetEffectiveEntries()<<" entries"
<<" of mean value "<<histo->GetMean()
<<std::endl ;
}
else
{ std::cout<<"What is "<<obj->GetName()<<" ?"<<std::endl ; }
}
}
}
//____________________________________________________
TObjArray* CreateRecoParamObject()
{
TObjArray *recos = new TObjArray(4);
AliTRDrecoParam *rec = 0x0;
recos->AddLast(rec = AliTRDrecoParam::GetLowFluxParam());
rec->SetEventSpecie(AliRecoParam::kLowMult);
rec->SetNameTitle("LOW", "TRD Low Flux Reco Param");
rec->SetStreamLevel(AliTRDrecoParam::kTracker, 1);
rec->SetAsDefault();
// further settings for low flux reco param
// reco->SetThisAndThat()
recos->AddLast(rec = AliTRDrecoParam::GetHighFluxParam());
rec->SetEventSpecie(AliRecoParam::kHighMult);
rec->SetNameTitle("HIGH", "TRD High Flux Reco Param");
rec->SetStreamLevel(AliTRDrecoParam::kTracker, 1);
recos->AddLast(rec = AliTRDrecoParam::GetCosmicTestParam());
rec->SetEventSpecie(AliRecoParam::kCosmic);
rec->SetNameTitle("COSMIC", "TRD Cosmic Reco Param");
rec->SetStreamLevel(AliTRDrecoParam::kTracker, 1);
rec->SetRawStreamVersion("FAST");
recos->AddLast(rec = AliTRDrecoParam::GetCosmicTestParam());
rec->SetEventSpecie(AliRecoParam::kCalib);
rec->SetNameTitle("CALIBRATION", "TRD Calibration Reco Param");
rec->SetStreamLevel(AliTRDrecoParam::kTracker, 1);
rec->SetRawStreamVersion("FAST");
// recos->AddLast(rec = AliTRDrecoParam::GetLowFluxParam());
// rec->SetNameTitle("HLT", "TRD HLT Reco Param");
// rec->SetChi2Y(.1);
// rec->SetChi2Z(5.);
return recos;
}
void ilceve_init_import_macros()
{
// Put macros in the list of browsables, add a macro browser to
// top-level GUI.
TString macdir("$(ILC_ROOT)/EVE/ilc-macros");
gSystem->ExpandPathName(macdir);
TFolder* f = gEve->GetMacroFolder();
void* dirhandle = gSystem->OpenDirectory(macdir.Data());
if (dirhandle != 0)
{
char* filename;
TPMERegexp re("\\.C$");
TObjArray names;
while ((filename = gSystem->GetDirEntry(dirhandle)) != 0)
{
if (re.Match(filename))
names.AddLast(new TObjString(filename));
}
names.Sort();
for (Int_t ii=0; ii<names.GetEntries(); ++ii)
{
TObjString * si = (TObjString*) names.At(ii);
f->Add(new TEveMacro(Form("%s/%s", macdir.Data(), (si->GetString()).Data())));
}
}
gSystem->FreeDirectory(dirhandle);
gROOT->GetListOfBrowsables()->Add(new TSystemDirectory(macdir.Data(), macdir.Data()));
{
TEveBrowser *br = gEve->GetBrowser();
TGFileBrowser *fb = 0;
fb = br->GetFileBrowser();
fb->GotoDir(macdir);
{
br->StartEmbedding(0);
fb = br->MakeFileBrowser();
fb->BrowseObj(f);
fb->Show();
br->StopEmbedding();
br->SetTabTitle("Macros", 0);
br->SetTab(0, 0);
}
}
}
void Example_tags(TString topDir = "/star/rcf/GC/daq/tags")
{
//////////////////////////////////////////////////////////////////////////
// //
// Example_tags.C //
// //
// shows how to use the STAR tags files //
// Input: top level directory //
// //
// what it does: //
// 1. creates TChain from all tags files down from the topDir //
// 2. loops over all events in the chain //
// //
// owner: Alexandre V. Vaniachine <*****@*****.**> //
//////////////////////////////////////////////////////////////////////////
gSystem->Load("libTable");
gSystem->Load("St_base");
// start benchmarks
gBenchmark = new TBenchmark();
gBenchmark->Start("total");
// set loop optimization level
gROOT->ProcessLine(".O4");
// gather all files from the same top directory into one chain
// topDir must end with "/"
topDir +='/';
St_FileSet dirs(topDir);
St_DataSetIter next(&dirs,0);
St_DataSet *set = 0;
TChain chain("Tag");
while ( (set = next()) ) {
if (strcmp(set->GetTitle(),"file") ||
!(strstr(set->GetName(),".tags.root"))) continue;
chain.Add(gSystem->ConcatFileName(topDir,set->Path()));
}
UInt_t nEvents = chain->GetEntries();
cout<<"chained "<<nEvents<<" events "<<endl;
TObjArray *files = chain.GetListOfFiles();
UInt_t nFiles = files->GetEntriesFast();
cout << "chained " << nFiles << " files from " << topDir << endl;
TObjArray *leaves = chain.GetListOfLeaves();
Int_t nleaves = leaves->GetEntriesFast();
TString tableName = " ";
TObjArray *tagTable = new TObjArray;
Int_t tableCount = 0;
Int_t *tableIndex = new Int_t[nleaves];
Int_t tagCount = 0;
// decode tag table names
for (Int_t l=0;l<nleaves;l++) {
TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
tagCount+=leaf->GetNdata();
TBranch *branch = leaf->GetBranch();
// new tag table name
if ( strstr(branch->GetName(), tableName.Data()) == 0 ) {
tableName = branch->GetName();
// the tableName is encoded in the branch Name before the "."
tableName.Resize(tableName->Last('.'));
tagTable->AddLast(new TObjString(tableName.Data()));
tableCount++;
}
tableIndex[l]=tableCount-1;
}
cout << " tot num tables, tags = " << tableCount << " "
<< tagCount << endl << endl;
//EXAMPLE 1: how to print out names of all tags and values for first event
for (l=0;l<nleaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
branch = leaf->GetBranch();
branch->GetEntry();
// tag comment is in the title
TString Title = leaf->GetTitle();
Int_t dim = leaf->GetNdata();
if (dim==1) {
Title.ReplaceAll('['," '");
Title.ReplaceAll(']',"'");
}
cout << "\n Table: ";
cout.width(10);
cout << ((TObjString*)tagTable->UncheckedAt(tableIndex[l]))->GetString()
<<" -- has tag: " << Title << endl;
for (Int_t i=0;i<dim;i++) {
cout <<" "<< leaf->GetName();
if (dim>1) cout << '['<<i<<']';
cout << " = " << leaf->GetValue(i) << endl;
}
}
// EXAMPLE 2: how to make a plot
c1 = new TCanvas("c1","Beam-Gas Rejection",600,1000);
gStyle->SetMarkerStyle(8);
chain->Draw("n_trk_tpc[0]:n_trk_tpc[1]");
// EXAMPLE 3: how to make a selection (write selected event numbers on the plot)
Int_t ncoll=0;
char aevent[10];
TText t(0,0,"a");
t.SetTextFont(52);
t.SetTextSize(0.02);
Float_t cut = 0.35;
cout <<"\n Events with ntrk>400 and |asim|<"<<cut<<endl;
//loop over all events: READ ONLY n_trk_tpc AND mEventNumber BRANCHES!
gBenchmark->Start("loop");
for (Int_t i=0;i<nFiles;i++) {
chain.LoadTree(*(chain.GetTreeOffset()+i));
TTree *T = chain.GetTree();
//must renew leaf pointer for each tree
TLeaf *ntrk = T->GetLeaf("n_trk_tpc");
TLeaf *run = T->GetLeaf("mRunNumber");
TLeaf *event = T->GetLeaf("mEventNumber");
for (Int_t j=0; j<T->GetEntries(); j++){
ntrk->GetBranch()->GetEntry(j);
event->GetBranch()->GetEntry(j);
run->GetBranch()->GetEntry(j);
Int_t Nm=ntrk->GetValue(0);
Int_t Np=ntrk->GetValue(1);
Int_t Ntrk = Np+Nm;
// avoid division by 0
Float_t asim = Np-Nm;
if (Ntrk>0) asim /= Ntrk;
if (-cut < asim&&asim < cut && Ntrk>400) {
cout<<" Run "<<(UInt_t)run->GetValue()
<<", Event "<<event->GetValue() <<endl;
ncoll++;
sprintf(aevent,"%d",event->GetValue());
t.DrawText(Np+10,Nm+10,aevent);
}
}
}
gBenchmark->Stop("loop");
t.SetTextSize(0.05);
t.DrawText(50,2550,"ntrk>400 and |(Np-Nm)/(Np+Nm)| < 0.35 ");
t.DrawText(500,-300,"Ntrk with tanl<0 ");
cout << " Selected " << ncoll << " collision candidates out of "
<< nEvents << " events" << endl;
// stop timer and print benchmarks
gBenchmark->Print("loop");
gBenchmark->Stop("total");
gBenchmark->Print("total");
}
AliCFTaskVertexingHF *AddTaskCFVertexingHF3Prong(TString suffixName="", const char* cutFile = "./DplustoKpipiCuts.root", Int_t configuration = AliCFTaskVertexingHF::kCheetah, Bool_t isKeepDfromB=kFALSE, Bool_t isKeepDfromBOnly=kFALSE, Int_t pdgCode = 411, Char_t isSign = 2, Bool_t useWeight=kFALSE, TString multFile="", Bool_t useNchWeight=kFALSE, Bool_t useNtrkWeight=kFALSE, TString estimatorFilename="", Int_t multiplicityEstimator = AliCFTaskVertexingHF::kNtrk10, Bool_t isPPbData = kFALSE, Double_t refMult=9.26, Bool_t isFineNtrkBin=kFALSE, TString multweighthistoname = "hNtrUnCorrEvWithCandWeight")
//AliCFContainer *AddTaskCFVertexingHF3Prong(const char* cutFile = "./DplustoKpipiCuts.root", Int_t configuration = AliCFTaskVertexingHF::kSnail, Bool_t isKeepDfromB=kFALSE, Bool_t isKeepDfromBOnly=kFALSE, Int_t pdgCode = 411, Char_t isSign = 2)
{
printf("Addig CF task using cuts from file %s\n",cutFile);
if (configuration == AliCFTaskVertexingHF::kSnail){
printf("The configuration is set to be SLOW --> all the variables will be used to fill the CF\n");
}
else if (configuration == AliCFTaskVertexingHF::kCheetah){
printf("The configuration is set to be FAST --> using only pt, y, ct, phi, zvtx, centrality, fake, multiplicity to fill the CF\n");
}
else if (configuration == AliCFTaskVertexingHF::kFalcon){
printf("The configuration is set to be FAST --> using only pt, y, centrality, multiplicity to fill the CF\n");
}
else{
printf("The configuration is not defined! returning\n");
return;
}
gSystem->Sleep(2000);
// isSign = 0 --> D+ only
// isSign = 1 --> D- only
// isSign = 2 --> both
TString expected;
if (isSign == 0 && pdgCode < 0){
AliError(Form("Error setting PDG code (%d) and sign (0 --> particle (%d) only): they are not compatible, returning",pdgCode));
return 0x0;
}
else if (isSign == 1 && pdgCode > 0){
AliError(Form("Error setting PDG code (%d) and sign (1 --> antiparticle (%d) only): they are not compatible, returning",pdgCode));
return 0x0;
}
else if (isSign > 2 || isSign < 0){
AliError(Form("Sign not valid (%d, possible values are 0, 1, 2), returning"));
return 0x0;
}
TFile* fileCuts = TFile::Open(cutFile);
if(!fileCuts || (fileCuts && !fileCuts->IsOpen())){
AliFatal(" Cut file not found");
return 0x0;
}
AliRDHFCutsDplustoKpipi *cutsDplustoKpipi = (AliRDHFCutsDplustoKpipi*)fileCuts->Get("AnalysisCuts");
TH1F *hMult=0x0;
if(multFile.EqualTo("") ) {
printf("Will not be corrected with weights \n");
}else{
TFile *fileMult = TFile::Open(multFile.Data());
if(isPPbData && multweighthistoname=="") {
hMult = (TH1F*)fileMult->Get("hNtrUnCorrEvWithCandWeight");
}
else if(!isPPbData && multweighthistoname==""){
hMult=(TH1F*)fileMult->Get("hGenPrimaryParticlesInelGt0");
}
else {
hMult=(TH1F*)fileMult->Get(multweighthistoname.Data());
}
}
// check that the fKeepD0fromB flag is set to true when the fKeepD0fromBOnly flag is true
// for now the binning is the same than for all D's
if(isKeepDfromBOnly) isKeepDfromB = true;
/*
Double_t ptmin_0_4;
Double_t ptmax_0_4;
Double_t ptmin_4_8;
Double_t ptmax_4_8;
Double_t ptmin_8_10;
Double_t ptmax_8_10;
if(!isKeepDfromB){
ptmin_0_4 = 0.0 ;
ptmax_0_4 = 4.0 ;
ptmin_4_8 = 4.0 ;
ptmax_4_8 = 8.0 ;
ptmin_8_10 = 8.0 ;
ptmax_8_10 = 10.0 ;
} else{
ptmin_0_4 = 0.0 ;
ptmax_0_4 = 3.0 ;
ptmin_4_8 = 3.0 ;
ptmax_4_8 = 5.0 ;
ptmin_8_10 = 5.0 ;
ptmax_8_10 = 10.0 ;
}
*/
//CONTAINER DEFINITION
Info("AliCFTaskVertexingHF","SETUP CONTAINER");
const Double_t phimax = 2*TMath::Pi();
//Setting up the container grid...
UInt_t nstep = 10; //number of selection steps: MC with limited acceptance, MC, Acceptance, Vertex, Refit, Reco (no cuts), RecoAcceptance, RecoITSClusters (RecoAcceptance included), RecoPPR (RecoAcceptance+RecoITSCluster included), RecoPID
// const Int_t nbinpt_0_4 = 8 ; //bins in pt from 0 to 4 GeV
// const Int_t nbinpt_4_8 = 4 ; //bins in pt from 4 to 8 GeV
// const Int_t nbinpt_8_10 = 1 ; //bins in pt from 8 to 10 GeV
/*
Int_t nbinpt_0_4;
Int_t nbinpt_4_8;
Int_t nbinpt_8_10;
if (!isKeepDfromB){
nbinpt_0_4 = 8 ; //bins in pt from 0 to 4 GeV
nbinpt_4_8 = 4 ; //bins in pt from 4 to 8 GeV
nbinpt_8_10 = 1 ; //bins in pt from 8 to 10 GeV
}else{
nbinpt_0_4 = 3 ; //bins in pt from 0 to 3 GeV
nbinpt_4_8 = 1 ; //bins in pt from 3 to 5 GeV
nbinpt_8_10 = 1 ; //bins in pt from 5 to 10 GeV
}
*/
const Int_t nbinpt = cutsDplustoKpipi->GetNPtBins(); // bins in pT
printf("pT: nbin (from cuts file) = %d\n",nbinpt);
const Int_t nbiny = 24 ; //bins in y
const Int_t nbinphi = 18 ; //bins in phi
const Int_t nbincT = 2 ; //bins in cT
const Int_t nbinpointing = 35 ; //bins in cosPointingAngle
const Int_t nbinpTpi_0_4 = 8 ; //bins in ptPi from 0 to 4 GeV
const Int_t nbinpTpi_4_8 = 4 ; //bins in ptPi from 4 to 8 GeV
const Int_t nbinpTpi_8_10 = 1 ; //bins in ptPi from 8 to 10 GeV
const Int_t nbinpTk_0_4 = 8 ; //bins in ptKa from 0 to 4 GeV
const Int_t nbinpTk_4_8 = 4 ; //bins in ptKa from 4 to 8 GeV
const Int_t nbinpTk_8_10 = 1 ; //bins in ptKa from 8 to 10 GeV
const Int_t nbinpTpi2_0_4 = 8 ; //bins in ptpi2 from 0 to 4 GeV
const Int_t nbinpTpi2_4_8 = 4 ; //bins in ptpi2 from 4 to 8 GeV
const Int_t nbinpTpi2_8_10 = 1 ; //bins in ptpi2 from 8 to 10 GeV
const Int_t nbinzvtx = 30 ; //bins in z vertex
const Int_t nbincent = 18; //bins in centrality
const Int_t nbincent_0_10 = 4; //bins in centrality between 0 and 10
const Int_t nbincent_10_60 = 10; //bins in centrality between 10 and 60
const Int_t nbincent_60_100 = 4; //bins in centrality between 60 and 100
const Int_t nbinfake = 3; //bins in fake
const Int_t nbinpointingXY = 50; //bins in cosPointingAngleXY
const Int_t nbinnormDecayLXY = 20; //bins in NormDecayLengthXY
const Int_t nbinmult = 49; //bins in multiplicity (total number)
const Int_t nbinmult_0_20 = 20; //bins in multiplicity between 0 and 20
const Int_t nbinmult_20_50 = 15; //bins in multiplicity between 20 and 50
const Int_t nbinmult_50_80 = 10; //bins in multiplicity between 50 and 80
const Int_t nbinmult_80_100 = 4; //bins in multiplicity between 80 and 100
const Int_t nbinmult_100_400 = 3; //bins in multiplicity between 100 and 400
if(isPPbData) nbinmult += nbinmult_100_400;
// Fine Ntrk bining setting
Double_t *binLimmultFine;
Int_t nbinmultTmp=nbinmult;
if(isFineNtrkBin){
Int_t nbinLimmultFine=100;
if(isPPbData) nbinLimmultFine = 200;
const UInt_t nbinMultFine = nbinLimmultFine;
binLimmultFine = new Double_t[nbinMultFine+1];
for (Int_t ibin0 = 0 ; ibin0<nbinMultFine+1; ibin0++){
binLimmultFine[ibin0] = ibin0;
}
nbinmultTmp=nbinLimmultFine;
}
const Int_t nbinmultTot=nbinmultTmp;
//the sensitive variables, their indices
const UInt_t ipT = 0;
const UInt_t iy = 1;
const UInt_t iphi = 2;
const UInt_t icT = 3;
const UInt_t ipointing = 4;
const UInt_t ipTpi = 5;
const UInt_t ipTk = 6;
const UInt_t ipTpi2 = 7;
const UInt_t izvtx = 8;
const UInt_t icent = 9;
const UInt_t ifake = 10;
const UInt_t ipointingXY = 11;
const UInt_t inormDecayLXY = 12;
const UInt_t imult = 13;
const Int_t nvarTot = 14 ; //number of variables on the grid:pt, y, cosThetaStar, pTpi, pTk, cT, dca, d0pi, d0K, d0xd0, cosPointingAngle, phi, zvtx, centrality, fake, cosPointingAngleXY, normDecayLengthXY, multiplicity
//arrays for the number of bins in each dimension
Int_t iBin[nvarTot];
//iBin[ipT]=nbinpt_0_4+nbinpt_4_8+nbinpt_8_10;
iBin[ipT]=nbinpt;
iBin[iy]=nbiny;
iBin[iphi]=nbinphi;
// iBin[icT]=nbincT_0_4+nbincT_4_8+nbincT_8_10;
//iBin[4]=nbinpointing_0_4+nbinpointing_4_8+nbinpointing_8_10;
iBin[icT]=nbincT;
iBin[ipointing]=nbinpointing;
iBin[ipTpi]=nbinpt;
iBin[ipTk]=nbinpt;
iBin[ipTpi2]=nbinpt;
iBin[izvtx]=nbinzvtx;
iBin[icent]=nbincent;
iBin[ifake]=nbinfake;
iBin[ipointingXY]=nbinpointingXY;
iBin[inormDecayLXY]=nbinnormDecayLXY;
iBin[imult]=nbinmultTot;
//arrays for lower bounds :
Double_t *binLimpT=new Double_t[iBin[ipT]+1];
Double_t *binLimy=new Double_t[iBin[iy]+1];
Double_t *binLimphi=new Double_t[iBin[iphi]+1];
Double_t *binLimcT=new Double_t[iBin[icT]+1];
Double_t *binLimpointing=new Double_t[iBin[ipointing]+1];
Double_t *binLimpTpi=new Double_t[iBin[ipTpi]+1];
Double_t *binLimpTk=new Double_t[iBin[ipTk]+1];
Double_t *binLimpTpi2=new Double_t[iBin[ipTpi2]+1];
Double_t *binLimzvtx=new Double_t[iBin[izvtx]+1];
Double_t *binLimcent=new Double_t[iBin[icent]+1];
Double_t *binLimfake=new Double_t[iBin[ifake]+1];
Double_t *binLimpointingXY=new Double_t[iBin[ipointingXY]+1];
Double_t *binLimnormDecayLXY=new Double_t[iBin[inormDecayLXY]+1];
Double_t *binLimmult=new Double_t[iBin[imult]+1];
// checking limits
/*
if (ptmax_0_4 != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","max lim 1st range != min lim 2nd range, please check!");
}
if (ptmax_4_8 != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","max lim 2nd range != min lim 3rd range, please check!");
}
*/
// values for bin lower bounds
// pt
Float_t* floatbinLimpT = cutsDplustoKpipi->GetPtBinLimits();
for (Int_t ibinpT = 0 ; ibinpT<iBin[ipT]+1; ibinpT++){
binLimpT[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTpi[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTk[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTpi2[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
}
for(Int_t i=0; i<=nbinpt; i++) printf("binLimpT[%d]=%f\n",i,binLimpT[i]);
/*
for(Int_t i=0; i<=nbinpt_0_4; i++) binLimpT[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbinpt_0_4*(Double_t)i ;
if (binLimpT[nbinpt_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for pt - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpt_4_8; i++) binLimpT[i+nbinpt_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbinpt_4_8*(Double_t)i ;
if (binLimpT[nbinpt_0_4+nbinpt_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for pt - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpt_8_10; i++) binLimpT[i+nbinpt_0_4+nbinpt_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbinpt_8_10*(Double_t)i ;
*/
// y
for(Int_t i=0; i<=nbiny; i++) binLimy[i]=(Double_t)ymin + (ymax-ymin) /nbiny*(Double_t)i ;
// Phi
for(Int_t i=0; i<=nbinphi; i++) binLimphi[i]=(Double_t)phimin + (phimax-phimin) /nbinphi*(Double_t)i ;
// cT
for(Int_t i=0; i<=nbincT; i++) binLimcT[i]=(Double_t)cTmin + (cTmax-cTmin) /nbincT*(Double_t)i ;
// cosPointingAngle
for(Int_t i=0; i<=nbinpointing; i++) binLimpointing[i]=(Double_t)cosmin + (cosmax-cosmin) /nbinpointing*(Double_t)i ;
/*
// ptPi
for(Int_t i=0; i<=nbincT_0_4; i++) binLimcT[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbincT_0_4*(Double_t)i ;
if (binLimcT[nbincT_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptPi - 1st range - differs from expected!");
}
for(Int_t i=0; i<=nbincT_4_8; i++) binLimcT[i+nbincT_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbincT_4_8*(Double_t)i ;
if (binLimcT[nbincT_0_4+nbincT_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptPi - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincT_8_10; i++) binLimcT[i+nbincT_0_4+nbincT_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbincT_8_10*(Double_t)i ;
// ptKa
for(Int_t i=0; i<=nbinpointing_0_4; i++) binLimpointing[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbinpointing_0_4*(Double_t)i ;
if (binLimpointing[nbinpointing_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptKa - 1st range - differs from expected!");
}
for(Int_t i=0; i<=nbinpointing_4_8; i++) binLimpointing[i+nbinpointing_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbinpointing_4_8*(Double_t)i ;
if (binLimpointing[nbinpointing_0_4+nbinpointing_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptKa - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpointing_8_10; i++) binLimpointing[i+nbinpointing_0_4+nbinpointing_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbinpointing_8_10*(Double_t)i ;
*/
// z Primary Vertex
for(Int_t i=0; i<=nbinzvtx; i++) {
binLimzvtx[i]=(Double_t)zvtxmin + (zvtxmax-zvtxmin) /nbinzvtx*(Double_t)i ;
}
// centrality
for(Int_t i=0; i<=nbincent_0_10; i++) binLimcent[i]=(Double_t)centmin_0_10 + (centmax_0_10-centmin_0_10)/nbincent_0_10*(Double_t)i ;
if (binLimcent[nbincent_0_10] != centmin_10_60) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for cent - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincent_10_60; i++) binLimcent[i+nbincent_0_10]=(Double_t)centmin_10_60 + (centmax_10_60-centmin_10_60)/nbincent_10_60*(Double_t)i ;
if (binLimcent[nbincent_0_10+nbincent_10_60] != centmin_60_100) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for cent - 2st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincent_60_100; i++) binLimcent[i+nbincent_0_10+nbincent_10_60]=(Double_t)centmin_60_100 + (centmax_60_100-centmin_60_100)/nbincent_60_100*(Double_t)i ;
// fake
for(Int_t i=0; i<=nbinfake; i++) {
binLimfake[i]=(Double_t)fakemin + (fakemax-fakemin)/nbinfake * (Double_t)i;
}
// cosPointingAngleXY
for(Int_t i=0; i<=nbinpointingXY; i++) binLimpointingXY[i]=(Double_t)cosminXY + (cosmaxXY-cosminXY) /nbinpointingXY*(Double_t)i ;
// normDecayLXY
for(Int_t i=0; i<=nbinnormDecayLXY; i++) binLimnormDecayLXY[i]=(Double_t)normDecLXYmin + (normDecLXYmax-normDecLXYmin) /nbinnormDecayLXY*(Double_t)i ;
// multiplicity
for(Int_t i=0; i<=nbinmult_0_20; i++) binLimmult[i]=(Double_t)multmin_0_20 + (multmax_0_20-multmin_0_20)/nbinmult_0_20*(Double_t)i ;
if (binLimmult[nbinmult_0_20] != multmin_20_50) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_20_50; i++) binLimmult[i+nbinmult_0_20]=(Double_t)multmin_20_50 + (multmax_20_50-multmin_20_50)/nbinmult_20_50*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50] != multmin_50_80) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_50_80; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50]=(Double_t)multmin_50_80 + (multmax_50_80-multmin_50_80)/nbinmult_50_80*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50+nbinmult_50_80] != multmin_80_100) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 3rd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_80_100; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50+nbinmult_50_80]=(Double_t)multmin_80_100 + (multmax_80_100-multmin_80_100)/nbinmult_80_100*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50+nbinmult_50_80+nbinmult_80_100] != multmin_100_400) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 4th range - differs from expected!\n");
}
if(isPPbData){
for (Int_t i = 0; i<=nbinmult_100_400; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50+nbinmult_50_80+nbinmult_80_100]= (Double_t)multmin_100_400 + (multmax_100_400-multmin_100_400)/nbinmult_100_400*(Double_t)i ;
}
//one "container" for MC
TString nameContainer="";
if(!isKeepDfromB) {
nameContainer="CFHFcontainer_DplustoKpipi_Prompt";
}
else if(isKeepDfromBOnly){
nameContainer="CFHFcontainer_DplustoKpipi_FromB";
}
else {
nameContainer="CFHFcontainer_DplustoKpipi_All";
}
nameContainer += suffixName.Data();
AliCFContainer* container;
if (configuration == AliCFTaskVertexingHF::kSnail){
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvarTot,iBin);
//setting the bin limits
printf("pt\n");
container -> SetBinLimits(ipT,binLimpT);
printf("y\n");
container -> SetBinLimits(iy,binLimy);
printf("Phi\n");
container -> SetBinLimits(iphi,binLimphi);
printf("cT\n");
container -> SetBinLimits(icT,binLimcT);
printf("pointing angle\n");
container -> SetBinLimits(ipointing,binLimpointing);
printf("ptpi\n");
container -> SetBinLimits(ipTpi,binLimpTpi);
printf("ptK\n");
container -> SetBinLimits(ipTk,binLimpTk);
printf("ptpi2\n");
container -> SetBinLimits(ipTpi2,binLimpTpi2);
printf("zvtx \n");
container -> SetBinLimits(izvtx,binLimzvtx);
printf("cent\n");
container -> SetBinLimits(icent,binLimcent);
printf("fake\n");
container -> SetBinLimits(ifake,binLimfake);
printf("pointingXY\n");
container -> SetBinLimits(ipointingXY,binLimpointingXY);
printf("normDecayLXY\n");
container -> SetBinLimits(inormDecayLXY,binLimnormDecayLXY);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imult,binLimmultFine);
else container -> SetBinLimits(imult,binLimmult);
container -> SetVarTitle(ipT,"pt");
container -> SetVarTitle(iy,"y");
container -> SetVarTitle(iphi, "phi");
container -> SetVarTitle(icT, "ct");
container -> SetVarTitle(ipointing, "pointing");
container -> SetVarTitle(ipTpi, "ptpi");
container -> SetVarTitle(ipTk, "ptK");
container -> SetVarTitle(ipTpi2, "ptpi2");
container -> SetVarTitle(izvtx, "zvtx");
container -> SetVarTitle(icent, "centrality");
container -> SetVarTitle(ifake, "fake");
container -> SetVarTitle(ipointingXY, "piointingXY");
container -> SetVarTitle(inormDecayLXY, "normDecayLXY");
container -> SetVarTitle(imult, "multiplicity");
}
else if (configuration == AliCFTaskVertexingHF::kCheetah){
//arrays for the number of bins in each dimension
const Int_t nvar = 8;
const UInt_t ipTFast = 0;
const UInt_t iyFast = 1;
const UInt_t icTFast = 2;
const UInt_t iphiFast = 3;
const UInt_t izvtxFast = 4;
const UInt_t icentFast = 5;
const UInt_t ifakeFast = 6;
const UInt_t imultFast = 7;
Int_t iBinFast[nvar];
iBinFast[ipTFast] = iBin[ipT];
iBinFast[iyFast] = iBin[iy];
iBinFast[icTFast] = iBin[icT];
iBinFast[iphiFast] = iBin[iphi];
iBinFast[izvtxFast] = iBin[izvtx];
iBinFast[icentFast] = iBin[icent];
iBinFast[ifakeFast] = iBin[ifake];
iBinFast[imultFast] = iBin[imult];
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvar,iBinFast);
printf("pt\n");
container -> SetBinLimits(ipTFast,binLimpT);
printf("y\n");
container -> SetBinLimits(iyFast,binLimy);
printf("ct\n");
container -> SetBinLimits(icTFast,binLimcT);
printf("phi\n");
container -> SetBinLimits(iphiFast,binLimphi);
printf("zvtx\n");
container -> SetBinLimits(izvtxFast,binLimzvtx);
printf("centrality\n");
container -> SetBinLimits(icentFast,binLimcent);
printf("fake\n");
container -> SetBinLimits(ifakeFast,binLimfake);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imultFast,binLimmultFine);
else container -> SetBinLimits(imultFast,binLimmult);
container -> SetVarTitle(ipTFast,"pt");
container -> SetVarTitle(iyFast,"y");
container -> SetVarTitle(icTFast, "ct");
container -> SetVarTitle(iphiFast, "phi");
container -> SetVarTitle(izvtxFast, "zvtx");
container -> SetVarTitle(icentFast, "centrality");
container -> SetVarTitle(ifakeFast, "fake");
container -> SetVarTitle(imultFast, "multiplicity");
}
else if (configuration == AliCFTaskVertexingHF::kFalcon){
//arrays for the number of bins in each dimension
const Int_t nvar = 4;
const UInt_t ipTSuperFast = 0;
const UInt_t iySuperFast = 1;
const UInt_t icentSuperFast = 2;
const UInt_t imultSuperFast = 3;
Int_t iBinSuperFast[nvar];
iBinSuperFast[ipTSuperFast] = iBin[ipT];
iBinSuperFast[iySuperFast] = iBin[iy];
iBinSuperFast[icentSuperFast] = iBin[icent];
iBinSuperFast[imultSuperFast] = iBin[imult];
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvar,iBinSuperFast);
printf("pt\n");
container -> SetBinLimits(ipTSuperFast,binLimpT);
printf("y\n");
container -> SetBinLimits(iySuperFast,binLimy);
printf("centrality\n");
container -> SetBinLimits(icentSuperFast,binLimcent);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imultSuperFast,binLimmultFine);
else container -> SetBinLimits(imultSuperFast,binLimmult);
container -> SetVarTitle(ipTSuperFast,"pt");
container -> SetVarTitle(iySuperFast,"y");
container -> SetVarTitle(icentSuperFast, "centrality");
container -> SetVarTitle(imultSuperFast, "multiplicity");
}
//return container;
container -> SetStepTitle(0, "MCLimAcc");
container -> SetStepTitle(1, "MC");
container -> SetStepTitle(2, "MCAcc");
container -> SetStepTitle(3, "RecoVertex");
container -> SetStepTitle(4, "RecoRefit");
container -> SetStepTitle(5, "Reco");
container -> SetStepTitle(6, "RecoAcc");
container -> SetStepTitle(7, "RecoITSCluster");
container -> SetStepTitle(8, "RecoCuts");
container -> SetStepTitle(9, "RecoPID");
//CREATE THE CUTS -----------------------------------------------
// Gen-Level kinematic cuts
AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
//Particle-Level cuts:
AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
Bool_t useAbsolute = kTRUE;
if (isSign != 2){
useAbsolute = kFALSE;
}
mcGenCuts->SetRequirePdgCode(pdgCode, useAbsolute); // kTRUE set in order to include antiparticle
mcGenCuts->SetAODMC(1); //special flag for reading MC in AOD tree (important)
// Acceptance cuts:
AliCFAcceptanceCuts* accCuts = new AliCFAcceptanceCuts("accCuts", "Acceptance cuts");
AliCFTrackKineCuts *kineAccCuts = new AliCFTrackKineCuts("kineAccCuts","Kine-Acceptance cuts");
kineAccCuts->SetPtRange(ptmin,ptmax);
kineAccCuts->SetEtaRange(etamin,etamax);
// Rec-Level kinematic cuts
AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
AliCFTrackQualityCuts *recQualityCuts = new AliCFTrackQualityCuts("recQualityCuts","rec-level quality cuts");
AliCFTrackIsPrimaryCuts *recIsPrimaryCuts = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts","rec-level isPrimary cuts");
printf("CREATE MC KINE CUTS\n");
TObjArray* mcList = new TObjArray(0) ;
mcList->AddLast(mcKineCuts);
mcList->AddLast(mcGenCuts);
printf("CREATE ACCEPTANCE CUTS\n");
TObjArray* accList = new TObjArray(0) ;
accList->AddLast(kineAccCuts);
printf("CREATE RECONSTRUCTION CUTS\n");
TObjArray* recList = new TObjArray(0) ; // not used!!
recList->AddLast(recKineCuts);
recList->AddLast(recQualityCuts);
recList->AddLast(recIsPrimaryCuts);
TObjArray* emptyList = new TObjArray(0);
//CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
printf("CREATE INTERFACE AND CUTS\n");
AliCFManager* man = new AliCFManager() ;
man->SetParticleContainer(container);
man->SetParticleCutsList(0 , mcList); // MC, Limited Acceptance
man->SetParticleCutsList(1 , mcList); // MC
man->SetParticleCutsList(2 , accList); // Acceptance
man->SetParticleCutsList(3 , emptyList); // Vertex
man->SetParticleCutsList(4 , emptyList); // Refit
man->SetParticleCutsList(5 , emptyList); // AOD
man->SetParticleCutsList(6 , emptyList); // AOD in Acceptance
man->SetParticleCutsList(7 , emptyList); // AOD with required n. of ITS clusters
man->SetParticleCutsList(8 , emptyList); // AOD Reco (PPR cuts implemented in Task)
man->SetParticleCutsList(9 , emptyList); // AOD Reco PID
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskCompareHF", "No analysis manager to connect to.");
return NULL;
}
//CREATE THE TASK
printf("CREATE TASK\n");
// create the task
AliCFTaskVertexingHF *task = new AliCFTaskVertexingHF("AliCFTaskVertexingHF",cutsDplustoKpipi);
task->SetConfiguration(configuration);
task->SetFillFromGenerated(kFALSE);
task->SetDecayChannel(31);
task->SetUseWeight(useWeight);
task->SetCFManager(man); //here is set the CF manager
task->SetSign(isSign);
task->SetCentralitySelection(kFALSE);
task->SetFakeSelection(0);
task->SetRejectCandidateIfNotFromQuark(kTRUE); // put to false if you want to keep HIJING D0!!
task->SetUseMCVertex(kFALSE); // put to true if you want to do studies on pp
task->SetUseNchWeight(useNchWeight); //correction with mult weight
if(useNchWeight || useNtrkWeight){
if(hMult) task->SetMCNchHisto(hMult);
else{
AliFatal("Histogram for multiplicity weights not found");
return 0x0;
}
task->SetUseNchWeight(kTRUE);
if(useNtrkWeight) task->SetUseNchTrackletsWeight();
}
if(isPPbData) {
task->SetIsPPbData(kTRUE);
}
if (isKeepDfromB && !isKeepDfromBOnly) task->SetDselection(2);
if (isKeepDfromB && isKeepDfromBOnly) task->SetDselection(1);
TF1* funcWeight = 0x0;
if (task->GetUseWeight()) {
funcWeight = (TF1*)fileCuts->Get("funcWeight");
if (funcWeight == 0x0){
Printf("FONLL Weights will be used");
}
else {
task->SetWeightFunction(funcWeight);
Printf("User-defined Weights will be used. The function being:");
task->GetWeightFunction()->Print();
}
}
task->SetMultiplicityEstimator(multiplicityEstimator);
if(estimatorFilename.EqualTo("") ) {
printf("Estimator file not provided, multiplicity corrected histograms will not be filled\n");
task->SetUseZvtxCorrectedNtrkEstimator(kFALSE);
} else{
TFile* fileEstimator=TFile::Open(estimatorFilename.Data());
if(!fileEstimator) {
AliFatal("File with multiplicity estimator not found");
return;
}
task->SetUseZvtxCorrectedNtrkEstimator(kTRUE);
task->SetReferenceMultiplcity(refMult);
if (isPPbData) { //load multiplicity estimators for pPb
const Char_t* periodNames[2] = {"LHC13b", "LHC13c"};
TProfile *multEstimatorAvg[2];
for (Int_t ip=0; ip < 2; ip++) {
multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
if (!multEstimatorAvg[ip]) {
AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
return;
}
}
task->SetMultiplVsZProfileLHC13b(multEstimatorAvg[0]);
task->SetMultiplVsZProfileLHC13c(multEstimatorAvg[1]);
} else { //load multiplicity estimators for pp
const Char_t* periodNames[4] = {"LHC10b", "LHC10c", "LHC10d", "LHC10e"};
TProfile* multEstimatorAvg[4];
for(Int_t ip=0; ip<4; ip++) {
multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
if (!multEstimatorAvg[ip]) {
AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
return;
}
}
task->SetMultiplVsZProfileLHC10b(multEstimatorAvg[0]);
task->SetMultiplVsZProfileLHC10c(multEstimatorAvg[1]);
task->SetMultiplVsZProfileLHC10d(multEstimatorAvg[2]);
task->SetMultiplVsZProfileLHC10e(multEstimatorAvg[3]);
}
}
Printf("***************** CONTAINER SETTINGS *****************");
Printf("decay channel = %d",(Int_t)task->GetDecayChannel());
Printf("FillFromGenerated = %d",(Int_t)task->GetFillFromGenerated());
Printf("Dselection = %d",(Int_t)task->GetDselection());
Printf("Sign = %d",(Int_t)task->GetSign());
Printf("Centrality selection = %d",(Int_t)task->GetCentralitySelection());
Printf("Fake selection = %d",(Int_t)task->GetFakeSelection());
Printf("RejectCandidateIfNotFromQuark selection = %d",(Int_t)task->GetRejectCandidateIfNotFromQuark());
Printf("UseMCVertex selection = %d",(Int_t)task->GetUseMCVertex());
Printf("***************END CONTAINER SETTINGS *****************\n");
//-----------------------------------------------------------//
// create correlation matrix for unfolding - only eta-pt //
//-----------------------------------------------------------//
Bool_t AcceptanceUnf = kTRUE; // unfold at acceptance level, otherwise PPR
Int_t thnDim[4];
//first half : reconstructed
//second half : MC
thnDim[0] = iBin[ipT];
thnDim[2] = iBin[ipT];
thnDim[1] = iBin[iy];
thnDim[3] = iBin[iy];
TString nameCorr="";
if(!isKeepDfromB) {
nameCorr="CFHFcorr_DplustoKpipi_Prompt";
}
else if(isKeepDfromBOnly){
nameCorr="CFHFcorr_DplustoKpipi_FromB";
}
else {
nameCorr="CFHFcorr_DplustoKpipi_All";
}
nameCorr += suffixName.Data();
THnSparseD* correlation = new THnSparseD(nameCorr,"THnSparse with correlations",4,thnDim);
Double_t** binEdges = new Double_t[2];
// set bin limits
binEdges[0]= binLimpT;
binEdges[1]= binLimy;
correlation->SetBinEdges(0,binEdges[0]);
correlation->SetBinEdges(2,binEdges[0]);
correlation->SetBinEdges(1,binEdges[1]);
correlation->SetBinEdges(3,binEdges[1]);
correlation->Sumw2();
// correlation matrix ready
//------------------------------------------------//
task->SetCorrelationMatrix(correlation); // correlation matrix for unfolding
// Create and connect containers for input/output
// ------ input data ------
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
// ----- output data -----
TString outputfile = AliAnalysisManager::GetCommonFileName();
TString output1name="", output2name="", output3name="", output4name="", output5name="";
output2name=nameContainer;
output3name=nameCorr;
output5name= "coutProfDp";
if(!isKeepDfromB) {
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_Prompt";
output1name="CFHFhist_DplustoKpipi_Prompt";
output3name+="_Prompt";
output4name= "Cuts_DplustoKpipi_Prompt";
output5name+="_Prompt";
}
else if(isKeepDfromBOnly){
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_FromB";
output1name="CFHFhist_DplustoKpipi_FromB";
output3name+="_FromB";
output4name= "Cuts_DplustoKpipi_FromB";
output5name+="_FromB";
}
else{
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_All";
output1name="CFHFhist_DplustoKpipi_All";
output3name+="_All";
output4name= "Cuts_DplustoKpipi_All";
output5name+="_All";
}
outputfile += suffixName.Data();
output1name += suffixName.Data();
output4name += suffixName.Data();
output5name += suffixName.Data();
//now comes user's output objects :
// output TH1I for event counting
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(output1name, TH1I::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output Correction Framework Container (for acceptance & efficiency calculations)
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(output2name, AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// Unfolding - correlation matrix
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(output3name, THnSparseD::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
AliAnalysisDataContainer *coutput4 = mgr->CreateContainer(output4name, AliRDHFCuts::Class(),AliAnalysisManager::kOutputContainer, outputfile.Data());
// estimators list
AliAnalysisDataContainer *coutput5 = mgr->CreateContainer(output5name, TList::Class(),AliAnalysisManager::kOutputContainer, outputfile.Data());
mgr->AddTask(task);
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,1,coutput1);
mgr->ConnectOutput(task,2,coutput2);
mgr->ConnectOutput(task,3,coutput3);
mgr->ConnectOutput(task,4,coutput4);
mgr->ConnectOutput(task,5,coutput5);
return task;
}
void composeTrackAnalysisbyAssociator(string FileListName, int FileNumber) {
if(debug) cout << FileListName << endl;
string theFileName;
ifstream composeFileList;
composeFileList.open(FileListName.c_str());
string OutputPlotNamepreFix = FileListName + "_";
string OutputPlotNameFix = ".png";
unsigned int EventNumber;
unsigned int trackingParticleMatch;
double recTrackPurity;
double recTrackrefMomentum;
double recTrackrefPhi;
double recTrackrefEta;
double recTrackinnerMomentum;
double recTrackinnerPhi;
double recTrackinnerEta;
unsigned int recTrackinnerValid;
double recTrackouterMomentum;
double recTrackouterPhi;
double recTrackouterEta;
unsigned int recTrackouterValid;
double simTrackinnerMomentum;
double simTrackinnerPhi;
double simTrackinnerEta;
unsigned int simTrackinnerMatch;
double simTrackouterMomentum;
double simTrackouterPhi;
double simTrackouterEta;
unsigned int simTrackouterMatch;
double recTrackinnerMomentumofTSOS;
double recTrackinnerPhiofTSOS;
double recTrackinnerEtaofTSOS;
unsigned int recTrackinnerValidofTSOS;
double recTrackouterMomentumofTSOS;
double recTrackouterPhiofTSOS;
double recTrackouterEtaofTSOS;
unsigned int recTrackouterValidofTSOS;
double recTrackimpactMomentumofTSOS;
double recTrackimpactPhiofTSOS;
double recTrackimpactEtaofTSOS;
unsigned int recTrackimpactValidofTSOS;
int recTrackCharge;
double simTrackMomentumPt;
double simTrackPhi;
double simTrackEta;
int simTrackCharge;
TObjArray* myEfficiencyHist = new TObjArray();
TObjArray* myParticleHist = new TObjArray();
TObjArray* mySTAHist = new TObjArray();
TObjArray* myChargeCheckHist = new TObjArray();
TObjArray* myDeltaPtHist = new TObjArray();
TObjArray* myDeltaPhiHist = new TObjArray();
TObjArray* myDeltaEtaHist = new TObjArray();
vector<string> TypeName;
TypeName.clear();
for(int Index = 0; Index < FileNumber; Index++) {
getline(composeFileList, theFileName);
TypeName.push_back(theFileName);
string fullFileName = "data/"+ theFileName + ".root";
if(debug) cout << theFileName << endl;
TFile* RootFile = TFile::Open(fullFileName.c_str());
TTree* T1 = (TTree*)RootFile->Get("ExTree");
T1->SetBranchAddress("EventNumber", &EventNumber);
T1->SetBranchAddress("trackingParticleMatch", &trackingParticleMatch);
T1->SetBranchAddress("recTrackPurity", &recTrackPurity);
T1->SetBranchAddress("recTrackrefMomentum", &recTrackrefMomentum);
T1->SetBranchAddress("recTrackrefPhi", &recTrackrefPhi);
T1->SetBranchAddress("recTrackrefEta", &recTrackrefEta);
T1->SetBranchAddress("recTrackinnerMomentum", &recTrackinnerMomentum);
T1->SetBranchAddress("recTrackinnerPhi", &recTrackinnerPhi);
T1->SetBranchAddress("recTrackinnerEta", &recTrackinnerEta);
T1->SetBranchAddress("recTrackinnerValid", &recTrackinnerValid);
T1->SetBranchAddress("recTrackouterMomentum", &recTrackouterMomentum);
T1->SetBranchAddress("recTrackouterPhi", &recTrackouterPhi);
T1->SetBranchAddress("recTrackouterEta", &recTrackouterEta);
T1->SetBranchAddress("recTrackouterValid", &recTrackouterValid);
T1->SetBranchAddress("simTrackinnerMomentum", &simTrackinnerMomentum);
T1->SetBranchAddress("simTrackinnerPhi", &simTrackinnerPhi);
T1->SetBranchAddress("simTrackinnerEta", &simTrackinnerEta);
T1->SetBranchAddress("simTrackinnerMatch", &simTrackinnerMatch);
T1->SetBranchAddress("simTrackouterMomentum", &simTrackouterMomentum);
T1->SetBranchAddress("simTrackouterPhi", &simTrackouterPhi);
T1->SetBranchAddress("simTrackouterEta", &simTrackouterEta);
T1->SetBranchAddress("simTrackouterMatch", &simTrackouterMatch);
T1->SetBranchAddress("recTrackinnerMomentumofTSOS", &recTrackinnerMomentumofTSOS);
T1->SetBranchAddress("recTrackinnerPhiofTSOS", &recTrackinnerPhiofTSOS);
T1->SetBranchAddress("recTrackinnerEtaofTSOS", &recTrackinnerEtaofTSOS);
T1->SetBranchAddress("recTrackinnerValidofTSOS", &recTrackinnerValidofTSOS);
T1->SetBranchAddress("recTrackouterMomentumofTSOS", &recTrackouterMomentumofTSOS);
T1->SetBranchAddress("recTrackouterPhiofTSOS", &recTrackouterPhiofTSOS);
T1->SetBranchAddress("recTrackouterEtaofTSOS", &recTrackouterEtaofTSOS);
T1->SetBranchAddress("recTrackouterValidofTSOS", &recTrackouterValidofTSOS);
T1->SetBranchAddress("recTrackimpactMomentumofTSOS", &recTrackimpactMomentumofTSOS);
T1->SetBranchAddress("recTrackimpactPhiofTSOS", &recTrackimpactPhiofTSOS);
T1->SetBranchAddress("recTrackimpactEtaofTSOS", &recTrackimpactEtaofTSOS);
T1->SetBranchAddress("recTrackimpactValidofTSOS", &recTrackimpactValidofTSOS);
T1->SetBranchAddress("recTrackCharge", &recTrackCharge);
T1->SetBranchAddress("simTrackMomentumPt", &simTrackMomentumPt);
T1->SetBranchAddress("simTrackPhi", &simTrackPhi);
T1->SetBranchAddress("simTrackEta", &simTrackEta);
T1->SetBranchAddress("simTrackCharge", &simTrackCharge);
string TempHistName;
TempHistName = theFileName + "_Efficiency2simPt";
TH1D* Efficiency2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_Particle2simPt";
TH1D* Particle2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_STA2simPt";
TH1D* STA2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_InverseChargeRato2simPt";
TH1D* InverseChargeRato2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaPt2simPt";
TH1D* DeltaPt2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaPhi2simPt";
TH1D* DeltaPhi2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaEta2simPt";
TH1D* DeltaEta2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_MaxPurity2simPt";
TH2D* MaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 6, 0., 1.2);
TempHistName = theFileName + "_Multiplicity2simPt";
TH2D* Multiplicity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 10, 0., 10.);
TempHistName = theFileName + "_ChargeCheck2simPt";
TH2D* ChargeCheck2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 5, -2.5, 2.5);
TempHistName = theFileName + "_simTrackMomentumPtmaxPurity2simPt";
TH2D* simTrackMomentumPtmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, 0, PtScale);
TempHistName = theFileName + "_simTrackPhimaxPurity2simPt";
TH2D* simTrackPhimaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_simTrackEtamaxPurity2simPt";
TH2D* simTrackEtamaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 400, -2.0, 2.0);
TempHistName = theFileName + "_recTrackimpactMomentumofTSOSmaxPurity2simPt";
TH2D* recTrackimpactMomentumofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, 0, PtScale);
TempHistName = theFileName + "_recTrackimpactPhiofTSOSmaxPurity2simPt";
TH2D* recTrackimpactPhiofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_recTrackimpactEtaofTSOSmaxPurity2simPt";
TH2D* recTrackimpactEtaofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 600, -3.0, 3.0);
TempHistName = theFileName + "_recTrackimpactValidofTSOSmaxPurity2simPt";
TH2D* recTrackimpactValidofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 2, 0., 2.);
TempHistName = theFileName + "_DeltaPtmaxPurity2simPt";
TH2D* DeltaPtmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, -1.*PtScale, PtScale);
TempHistName = theFileName + "_DeltaPhimaxPurity2simPt";
TH2D* DeltaPhimaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_DeltaEtamaxPurity2simPt";
TH2D* DeltaEtamaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 400, -2.0, 2.0);
unsigned int trackingParticleMatch_temp;
unsigned int efficiency_temp;
double recTrackPurity_temp;
double recTrackrefMomentum_temp;
double recTrackrefPhi_temp;
double recTrackrefEta_temp;
double recTrackinnerMomentum_temp;
double recTrackinnerPhi_temp;
double recTrackinnerEta_temp;
unsigned int recTrackinnerValid_temp;
double recTrackouterMomentum_temp;
double recTrackouterPhi_temp;
double recTrackouterEta_temp;
unsigned int recTrackouterValid_temp;
double simTrackinnerMomentum_temp;
double simTrackinnerPhi_temp;
double simTrackinnerEta_temp;
unsigned int simTrackinnerMatch_temp;
double simTrackouterMomentum_temp;
double simTrackouterPhi_temp;
double simTrackouterEta_temp;
unsigned int simTrackouterMatch_temp;
double recTrackinnerMomentumofTSOS_temp;
double recTrackinnerPhiofTSOS_temp;
double recTrackinnerEtaofTSOS_temp;
unsigned int recTrackinnerValidofTSOS_temp;
double recTrackouterMomentumofTSOS_temp;
double recTrackouterPhiofTSOS_temp;
double recTrackouterEtaofTSOS_temp;
unsigned int recTrackouterValidofTSOS_temp;
double recTrackimpactMomentumofTSOS_temp;
double recTrackimpactPhiofTSOS_temp;
double recTrackimpactEtaofTSOS_temp;
unsigned int recTrackimpactValidofTSOS_temp;
int recTrackCharge_temp;
double simTrackMomentumPt_temp;
double simTrackPhi_temp;
double simTrackEta_temp;
int simTrackCharge_temp;
int Nentries = T1->GetEntries();
for(int i = 0; i < Nentries; i++) {
T1->GetEntry(i);
if(trackingParticleMatch == 0) {
MaxPurity2simPtHist->Fill(simTrackMomentumPt, 0);
Multiplicity2simPtHist->Fill(simTrackMomentumPt, 0);
int tempParticleBinNumber = Particle2simPtHist->FindBin(simTrackMomentumPt);
double tempParticleBinValue = Particle2simPtHist->GetBinContent(tempParticleBinNumber);
tempParticleBinValue += 1.;
Particle2simPtHist->SetBinContent(tempParticleBinNumber, tempParticleBinValue);
}
else {
efficiency_temp = 1;
trackingParticleMatch_temp = trackingParticleMatch;
recTrackPurity_temp = recTrackPurity;
recTrackrefMomentum_temp = recTrackrefMomentum;
recTrackrefPhi_temp = recTrackrefPhi;
recTrackrefEta_temp = recTrackrefEta;
recTrackinnerMomentum_temp = recTrackinnerMomentum;
recTrackinnerPhi_temp = recTrackinnerPhi;
recTrackinnerEta_temp = recTrackinnerEta;
recTrackinnerValid_temp = recTrackinnerValid;
recTrackouterMomentum_temp = recTrackouterMomentum;
recTrackouterPhi_temp = recTrackouterPhi;
recTrackouterEta_temp = recTrackouterEta;
recTrackouterValid_temp = recTrackouterValid;
simTrackinnerMomentum_temp = simTrackinnerMomentum;
simTrackinnerPhi_temp = simTrackinnerPhi;
simTrackinnerEta_temp = simTrackinnerEta;
simTrackinnerMatch_temp = simTrackinnerMatch;
simTrackouterMomentum_temp = simTrackouterMomentum;
simTrackouterPhi_temp = simTrackouterPhi;
simTrackouterEta_temp = simTrackouterEta;
simTrackouterMatch_temp = simTrackouterMatch;
recTrackinnerMomentumofTSOS_temp = recTrackinnerMomentumofTSOS;
recTrackinnerPhiofTSOS_temp = recTrackinnerPhiofTSOS;
recTrackinnerEtaofTSOS_temp = recTrackinnerEtaofTSOS;
recTrackinnerValidofTSOS_temp = recTrackinnerValidofTSOS;
recTrackouterMomentumofTSOS_temp = recTrackouterMomentumofTSOS;
recTrackouterPhiofTSOS_temp = recTrackouterPhiofTSOS;
recTrackouterEtaofTSOS_temp = recTrackouterEtaofTSOS;
recTrackouterValidofTSOS_temp = recTrackouterValidofTSOS;
recTrackimpactMomentumofTSOS_temp = recTrackimpactMomentumofTSOS;
recTrackimpactPhiofTSOS_temp = recTrackimpactPhiofTSOS;
recTrackimpactEtaofTSOS_temp = recTrackimpactEtaofTSOS;
recTrackimpactValidofTSOS_temp = recTrackimpactValidofTSOS;
recTrackCharge_temp = recTrackCharge;
simTrackMomentumPt_temp = simTrackMomentumPt;
simTrackPhi_temp = simTrackPhi;
simTrackEta_temp = simTrackEta;
simTrackCharge_temp = simTrackCharge;
bool nextStep = true;
while(nextStep) {
i++;
T1->GetEntry(i);
if(trackingParticleMatch <= trackingParticleMatch_temp)
nextStep = false;
else
trackingParticleMatch_temp = trackingParticleMatch;
if(nextStep == true && recTrackPurity_temp < recTrackPurity) {
if(debug) cout << "step another match, trackingParticleMatch_temp: " << trackingParticleMatch_temp << endl;
//trackingParticleMatch_temp = trackingParticleMatch;
recTrackPurity_temp = recTrackPurity;
recTrackrefMomentum_temp = recTrackrefMomentum;
recTrackrefPhi_temp = recTrackrefPhi;
recTrackrefEta_temp = recTrackrefEta;
recTrackinnerMomentum_temp = recTrackinnerMomentum;
recTrackinnerPhi_temp = recTrackinnerPhi;
recTrackinnerEta_temp = recTrackinnerEta;
recTrackinnerValid_temp = recTrackinnerValid;
recTrackouterMomentum_temp = recTrackouterMomentum;
recTrackouterPhi_temp = recTrackouterPhi;
recTrackouterEta_temp = recTrackouterEta;
recTrackouterValid_temp = recTrackouterValid;
simTrackinnerMomentum_temp = simTrackinnerMomentum;
simTrackinnerPhi_temp = simTrackinnerPhi;
simTrackinnerEta_temp = simTrackinnerEta;
simTrackinnerMatch_temp = simTrackinnerMatch;
simTrackouterMomentum_temp = simTrackouterMomentum;
simTrackouterPhi_temp = simTrackouterPhi;
simTrackouterEta_temp = simTrackouterEta;
simTrackouterMatch_temp = simTrackouterMatch;
recTrackinnerMomentumofTSOS_temp = recTrackinnerMomentumofTSOS;
recTrackinnerPhiofTSOS_temp = recTrackinnerPhiofTSOS;
recTrackinnerEtaofTSOS_temp = recTrackinnerEtaofTSOS;
recTrackinnerValidofTSOS_temp = recTrackinnerValidofTSOS;
recTrackouterMomentumofTSOS_temp = recTrackouterMomentumofTSOS;
recTrackouterPhiofTSOS_temp = recTrackouterPhiofTSOS;
recTrackouterEtaofTSOS_temp = recTrackouterEtaofTSOS;
recTrackouterValidofTSOS_temp = recTrackouterValidofTSOS;
recTrackimpactMomentumofTSOS_temp = recTrackimpactMomentumofTSOS;
recTrackimpactPhiofTSOS_temp = recTrackimpactPhiofTSOS;
recTrackimpactEtaofTSOS_temp = recTrackimpactEtaofTSOS;
recTrackimpactValidofTSOS_temp = recTrackimpactValidofTSOS;
recTrackCharge_temp = recTrackCharge;
simTrackMomentumPt_temp = simTrackMomentumPt;
simTrackPhi_temp = simTrackPhi;
simTrackEta_temp = simTrackEta;
simTrackCharge_temp = simTrackCharge;
}
}
i--;
//if(debug) cout << "Filling Multiplicity " << trackingParticleMatch_temp << endl;
MaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackPurity_temp);
Multiplicity2simPtHist->Fill(simTrackMomentumPt_temp, trackingParticleMatch_temp);
ChargeCheck2simPtHist->Fill(simTrackMomentumPt_temp, simTrackCharge_temp*recTrackCharge_temp);
simTrackMomentumPtmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackMomentumPt_temp);
simTrackPhimaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackPhi_temp);
simTrackEtamaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackEta_temp);
recTrackimpactMomentumofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactMomentumofTSOS_temp);
recTrackimpactPhiofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactPhiofTSOS_temp);
recTrackimpactEtaofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactEtaofTSOS_temp);
recTrackimpactValidofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactValidofTSOS_temp);
DeltaPtmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, (recTrackimpactMomentumofTSOS_temp-simTrackMomentumPt_temp)/simTrackMomentumPt_temp);
DeltaPhimaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactPhiofTSOS_temp-simTrackPhi_temp);
DeltaEtamaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactEtaofTSOS_temp-simTrackEta_temp);
int tempParticleBinNumber = STA2simPtHist->FindBin(simTrackMomentumPt_temp);
double tempParticleBinValue = Particle2simPtHist->GetBinContent(tempParticleBinNumber);
tempParticleBinValue += 1.;
Particle2simPtHist->SetBinContent(tempParticleBinNumber, tempParticleBinValue);
double tempSTABinValue = STA2simPtHist->GetBinContent(tempParticleBinNumber);
tempSTABinValue += 1.;
STA2simPtHist->SetBinContent(tempParticleBinNumber, tempSTABinValue);
}
}
for(int PtIndex = 1; PtIndex <= (int)(PtScale/2); PtIndex++) {
double ParticleBinValue = Particle2simPtHist->GetBinContent(PtIndex);
double STABinValue = STA2simPtHist->GetBinContent(PtIndex);
if(ParticleBinValue == 0.)
ParticleBinValue += 1.;
double EfficiencyBinValue = STABinValue / ParticleBinValue * 100.;
double EfficiencyBinError = sqrt(EfficiencyBinValue * (100. - EfficiencyBinValue) / ParticleBinValue);
cout << ParticleBinValue << ", " << STABinValue << ", " << EfficiencyBinValue << endl;
Efficiency2simPtHist->SetBinContent(PtIndex, EfficiencyBinValue);
Efficiency2simPtHist->SetBinError(PtIndex, EfficiencyBinError);
TH1D* ChargeCheckHist = ChargeCheck2simPtHist->ProjectionY("ChargeCheck", PtIndex, PtIndex, "o");
double ReverseChargeBinValue = ChargeCheckHist->GetBinContent(2);
double CoverseChargeBinValue = ChargeCheckHist->GetBinContent(4);
double TotalChargeBinValue = ReverseChargeBinValue + CoverseChargeBinValue;
if(TotalChargeBinValue == 0.);
TotalChargeBinValue += 1.;
double ReverseChargeRato = ReverseChargeBinValue / TotalChargeBinValue;
InverseChargeRato2simPtHist->SetBinContent(PtIndex, ReverseChargeRato);
TH1D* DeltaPtHist = DeltaPtmaxPurity2simPtHist->ProjectionY("DeltaPt", PtIndex, PtIndex, "o");
double DeltaPtMean = DeltaPtHist->GetMean();
double DeltaPtRMS = DeltaPtHist->GetRMS();
DeltaPt2simPtHist->SetBinContent(PtIndex, DeltaPtMean);
DeltaPt2simPtHist->SetBinError(PtIndex, DeltaPtRMS);
TH1D* DeltaPhiHist = DeltaPhimaxPurity2simPtHist->ProjectionY("DeltaPhi", PtIndex, PtIndex, "o");
double DeltaPhiMean = DeltaPhiHist->GetMean();
double DeltaPhiRMS = DeltaPhiHist->GetRMS();
DeltaPhi2simPtHist->SetBinContent(PtIndex, DeltaPhiMean);
DeltaPhi2simPtHist->SetBinError(PtIndex, DeltaPhiRMS);
TH1D* DeltaEtaHist = DeltaEtamaxPurity2simPtHist->ProjectionY("DeltaEta", PtIndex, PtIndex, "o");
double DeltaEtaMean = DeltaEtaHist->GetMean();
double DeltaEtaRMS = DeltaEtaHist->GetRMS();
DeltaEta2simPtHist->SetBinContent(PtIndex, DeltaEtaMean);
DeltaEta2simPtHist->SetBinError(PtIndex, DeltaEtaRMS);
}
myEfficiencyHist->AddLast(Efficiency2simPtHist);
myParticleHist->AddLast(Particle2simPtHist);
mySTAHist->AddLast(STA2simPtHist);
myChargeCheckHist->AddLast(InverseChargeRato2simPtHist);
myDeltaPtHist->AddLast(DeltaPt2simPtHist);
}
double minX = 0;
double minY = 0;
double maxX = 110;
double maxY = 40;
TCanvas* myCanvas = new TCanvas("Canvas", "Canvas", 800, 600);
myCanvas->cd();
TPad* myPad = new TPad("Pad", "Pad", 0, 0, 1, 1);
myPad->Draw();
myPad->cd();
((TH1D*)(myParticleHist->At(0)))->SetStats(0);
((TH1D*)(myParticleHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myParticleHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myParticleHist->At(0)))->Draw();
for(int Index = 0; Index < FileNumber; Index++) {
((TH1D*)(mySTAHist->At(Index)))->SetStats(0);
((TH1D*)(mySTAHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(mySTAHist->At(Index)))->Draw("same");
}
TLegend *STALeg = new TLegend(0.6,0.1,0.9,0.3);
STALeg->SetBorderSize(1);
TString LegKey = "ParticleTrack";
STALeg->AddEntry(myParticleHist->At(0), LegKey, "lpf");
for(int Index = 0; Index < FileNumber; Index++) {
LegKey = TypeName[Index];
STALeg->AddEntry(mySTAHist->At(Index), LegKey, "lpf");
}
STALeg->Draw();
string SaveName = OutputPlotNamepreFix + "_STA2simPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
myPad->Clear();
myPad->Update();
double YScale = myPad->GetUymax() / 110.;
((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myEfficiencyHist->At(0)))->SetStats(0);
((TH1D*)(myEfficiencyHist->At(0)))->Scale(YScale);
((TH1D*)(myEfficiencyHist->At(0)))->SetLineColor(kRed);
((TH1D*)(myEfficiencyHist->At(0)))->Draw("same,ah");
for(int Index = 1; Index < FileNumber; Index++) {
((TH1D*)(myEfficiencyHist->At(Index)))->SetStats(0);
((TH1D*)(myEfficiencyHist->At(Index)))->Scale(YScale);
((TH1D*)(myEfficiencyHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(myEfficiencyHist->At(Index)))->Draw("same,ah");
}
myPad->Update();
if(debug) cout << "Y: " << myPad->GetUymax() << endl;
double YAxisMinValue=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetXmin();
double YAxisMaxValue=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetXmax();
int YAxisNBins=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetNbins();
TGaxis* YAxis = new TGaxis(myPad->GetUxmin(), myPad->GetUymin(), myPad->GetUxmin(), myPad->GetUymax(), 0, 110, 510, "-R");
YAxis->SetLineColor(kGreen);
YAxis->SetLabelColor(kGreen);
YAxis->SetTitle("Efficiency of STA for simPts");
YAxis->CenterTitle(1);
YAxis->Draw();
double XAxisMinValue=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetXmin();
double XAxisMaxValue=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetXmax();
int XAxisNBins=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetNbins();
TGaxis* XAxis = new TGaxis(myPad->GetUxmin(), myPad->GetUymin(), myPad->GetUxmax(), myPad->GetUymin(), XAxisMinValue, XAxisMaxValue, 510, "+L");
XAxis->SetTitle("simPt/Gev");
XAxis->CenterTitle(1);
XAxis->Draw();
TLegend *EffLeg = new TLegend(0.1,0.9,0.4,1.0);
EffLeg->SetBorderSize(1);
for(int Index = 0; Index < FileNumber; Index++) {
TString LegKey = TypeName[Index];
EffLeg->AddEntry(myEfficiencyHist->At(Index), LegKey, "lpf");
}
EffLeg->Draw();
string SaveName = OutputPlotNamepreFix + "_Eff2simPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
((TH1D*)(myDeltaPtHist->At(0)))->SetStats(0);
((TH1D*)(myDeltaPtHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myDeltaPtHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(0)))->GetYaxis()->SetTitle("deltPt/simPt");
((TH1D*)(myDeltaPtHist->At(0)))->GetYaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(0)))->SetLineColor(kRed);
((TH1D*)(myDeltaPtHist->At(0)))->Draw("");
for(int Index = 1; Index < FileNumber; Index++) {
((TH1D*)(myDeltaPtHist->At(Index)))->SetStats(0);
//((TH1D*)(myDeltaPtHist->At(Index)))->GetXaxis()->SetTitle("simPt/Gev");
//((TH1D*)(myDeltaPtHist->At(Index)))->GetXaxis()->CenterTitle(1);
//((TH1D*)(myDeltaPtHist->At(Index)))->GetYaxis()->SetTitle("deltPt/simPt");
//((TH1D*)(myDeltaPtHist->At(Index)))->GetYaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(myDeltaPtHist->At(Index)))->Draw("same");
//SaveName = OutputPlotNamepreFix + TypeName[Index] + "DeltaPt" + OutputPlotNameFix;
//myCanvas->SaveAs(SaveName.c_str());
}
TLegend *PtLeg = new TLegend(0.6,0.8,0.9,0.9);
PtLeg->SetBorderSize(1);
for(int Index = 0; Index < FileNumber; Index++) {
TString LegKey = TypeName[Index];
PtLeg->AddEntry(myDeltaPtHist->At(Index), LegKey, "lpf");
}
PtLeg->Draw();
SaveName = OutputPlotNamepreFix + "_DeltaPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
}
void TBDataParser::OnStartElement(const char *element, const TList *attributes)
{
TXMLAttr *attr;
TIter next(attributes);
char *name = element;
_currentElement = new TString(element);
char *method = NULL;
while ((attr = (TXMLAttr*) next())) {
char *attrName = attr->GetName();
char *attrValue = attr->GetValue();
if(!strcmp(attrName, "name")) {
name = attrValue;
}
if(!strcmp(attrName, "method")) {
method = attrValue;
_currentMethod = new TString(method);
}
}
TFolder *currentFolder = _foldersStack->Last();
if(!strcmp(element, "vector")) {
TString *nameString = new TString(name);
vector<float> *values = new vector<float>;
_values = values;
nameString->ReplaceAll(" ","_");
TObjString *currentVector = new TObjString(nameString->Data());
TObjArray *vectorsStack = _vectorsStack;
vectorsStack->AddLast(currentVector);
TString *joinedName = new TString(((TObjString *) vectorsStack->First())->GetString().Data());
for(Int_t i = 1; i < vectorsStack->GetEntries(); i++) {
joinedName->Append("_");
joinedName->Append(((TObjString *) vectorsStack->At(i))->GetString().Data());
}
TObjString *joinedNameObj = new TObjString(joinedName->Data());
TObjArray *joinedNameStack = _joinedNameStack;
TNtuple *vector = new TNtuple(joinedName->Data(),joinedName->Data(),"values");
_vector = vector;
currentFolder->Add(vector);
if(joinedNameStack->Contains(joinedName->Data()))
cout << joinedName->Data() << "Error: " << "vector already exists. Be sure that in your XML file every vector has a unique path + name combination" << endl;
joinedNameStack->Add(joinedNameObj);
return;
}
_foldersStack->AddLast(currentFolder->AddFolder(name, name));
}
void getHistosFromRE(const string& mhid,
const string& filepath,
const string& sre,
vector<std::pair<string,wTH1*> >& v_wth1)
{
if (gl_verbose)
cout<<"Searching for regexp "<<sre<<" in "<<filepath;
// allow for multiple regexes in OR combination
//
vector<string> v_regexes;
Tokenize(sre,v_regexes,"|");
if (!v_regexes.size())
v_regexes.push_back(sre);
// Build validated TRegexp arguments in preparation for directory recursion
//
TObjArray *Args = new TObjArray();
for (size_t i=0; i<v_regexes.size(); i++) {
TRegexp re(v_regexes[i].c_str(),kTRUE);
if (re.Status() != TRegexp::kOK) {
cerr << "The regexp " << v_regexes[i] << " is invalid, Status() = ";
cerr << re.Status() << endl;
exit(-1);
}
else {
Args->AddLast(new TObjString(v_regexes[i].c_str()));
}
}
// Get the root file
//
TFile *rootfile = openRootFile(filepath);
if (!rootfile) {
cerr << "File failed to open, " << filepath << endl;
Args->Delete();
delete Args;
return;
}
// Do the recursion, collect matches
//
TObjArray *Matches = new TObjArray();
recurseDirs(rootfile, ®exMatchHisto, Args, Matches);
Args->Delete();
delete Args;
// Returns two objects per match:
// 1. the (string) path that was matched and
// 2. the object whose path matched
//
int nx2matches = Matches->GetEntriesFast();
if (gl_verbose) cout << "... " << nx2matches/2 << " match(es) found.";
// Add the matches to the global map of histos
//
int istart = v_wth1.size();
for (int i=0; i<nx2matches; i+=2) {
TString fullspec = ((TObjString *)(*Matches)[i])->GetString();
wTH1 *wth1 = new wTH1((TH1 *)((*Matches)[i+1]));
wth1->histo()->UseCurrentStyle();
wth1->histo()->SetLineColor(((i/2)%9)+1);
wth1->histo()->SetLineStyle((i/18)+1);
wth1->histo()->SetLineWidth(2);
wth1->SetLegendEntry(wth1->histo()->GetName());
string hidi= mhid+"_"+int2str(istart+(i/2));
v_wth1.push_back(std::pair<string,wTH1 *>(hidi,wth1));
//glmap_objpath2id.insert(pair<string,string>(fullspec,hidi));
glmap_id2histo.insert(pair<string,wTH1 *>(hidi,wth1));
glmap_id2objpath.insert(pair<string,string>(hidi,string(fullspec.Data())));
}
//Matches->Delete(); // need the histos!
delete Matches;
if (gl_verbose) cout << endl;
} // getHistosFromRE
void RPCSeedValidator(string FileName) {
gStyle->SetOptStat("");
gStyle->SetOptTitle(0);
if(debug) cout << FileName << endl;
string theFileName = "../" + FileName;
TFile* RootFile = TFile::Open(theFileName.c_str());
string OutputPlotNameFix = ".eps";
string FinalOutput = FileName + "_";
unsigned int EventNumber;
int SimTrackId;
int SimTrackType;
double SimTrackMomentum;
double SimTrackDirectionPhi;
int SimTrackCharge;
int SimTrackvalid;
bool PassSegmentFilter;
double SimMomentumPtatRef;
double SimDirectionPhiatRef;
double SimDirectionEtaatRef;
double SimBendingPhi;
double SimBendingEntryPositionX;
double SimBendingEntryPositionY;
double SimBendingEntryPositionZ;
double SimBendingLeavePositionX;
double SimBendingLeavePositionY;
double SimBendingLeavePositionZ;
unsigned int SeedNumber;
int SeedCharge;
double SeedPurity;
double SeedQuality;
double RecMomentumPtatRef;
double RecDirectionPhiatRef;
double RecDirectionEtaatRef;
double RecBendingPhi;
double RecBendingEntryPositionX;
double RecBendingEntryPositionY;
double RecBendingEntryPositionZ;
double RecBendingLeavePositionX;
double RecBendingLeavePositionY;
double RecBendingLeavePositionZ;
double RecBendingLastPhi;
TTree* T0 = (TTree*)RootFile->Get("ExTree");
T0->SetBranchAddress("EventNumber", &EventNumber);
T0->SetBranchAddress("SimTrackId", &SimTrackId);
T0->SetBranchAddress("SimTrackType", &SimTrackType);
T0->SetBranchAddress("SimTrackMomentum", &SimTrackMomentum);
T0->SetBranchAddress("SimTrackDirectionPhi", &SimTrackDirectionPhi);
T0->SetBranchAddress("SimTrackCharge", &SimTrackCharge);
T0->SetBranchAddress("SimTrackValid", &SimTrackvalid);
T0->SetBranchAddress("PassSegmentFilter", &PassSegmentFilter);
T0->SetBranchAddress("SimMomentumPtatRef", &SimMomentumPtatRef);
T0->SetBranchAddress("SimDirectionPhiatRef", &SimDirectionPhiatRef);
T0->SetBranchAddress("SimDirectionEtaatRef", &SimDirectionEtaatRef);
T0->SetBranchAddress("SimBendingPhi", &SimBendingPhi);
T0->SetBranchAddress("SimBendingEntryPositionX", &SimBendingEntryPositionX);
T0->SetBranchAddress("SimBendingEntryPositionY", &SimBendingEntryPositionY);
T0->SetBranchAddress("SimBendingEntryPositionZ", &SimBendingEntryPositionZ);
T0->SetBranchAddress("SimBendingLeavePositionX", &SimBendingLeavePositionX);
T0->SetBranchAddress("SimBendingLeavePositionY", &SimBendingLeavePositionY);
T0->SetBranchAddress("SimBendingLeavePositionZ", &SimBendingLeavePositionZ);
T0->SetBranchAddress("SeedNumber", &SeedNumber);
T0->SetBranchAddress("SeedCharge", &SeedCharge);
T0->SetBranchAddress("SeedPurity", &SeedPurity);
T0->SetBranchAddress("SeedQuality", &SeedQuality);
T0->SetBranchAddress("RecMomentumPtatRef", &RecMomentumPtatRef);
T0->SetBranchAddress("RecDirectionPhiatRef", &RecDirectionPhiatRef);
T0->SetBranchAddress("RecDirectionEtaatRef", &RecDirectionEtaatRef);
T0->SetBranchAddress("RecBendingPhi", &RecBendingPhi);
T0->SetBranchAddress("RecBendingEntryPositionX", &RecBendingEntryPositionX);
T0->SetBranchAddress("RecBendingEntryPositionY", &RecBendingEntryPositionY);
T0->SetBranchAddress("RecBendingEntryPositionZ", &RecBendingEntryPositionZ);
T0->SetBranchAddress("RecBendingLeavePositionX", &RecBendingLeavePositionX);
T0->SetBranchAddress("RecBendingLeavePositionY", &RecBendingLeavePositionY);
T0->SetBranchAddress("RecBendingLeavePositionZ", &RecBendingLeavePositionZ);
T0->SetBranchAddress("RecBendingLastPhi", &RecBendingLastPhi);
TH1D* SimTrackvalidHist = (TH1D*) new TH1D("SimTrackvalidHist", "SimTrackvalidHist", 2, 0, 2);
TH1D* SeedPtforSimTrackvalidHist = (TH1D*) new TH1D("SeedPtforSimTrackvalidHist", "SeedPtforSimTrackvalidHist", 100, 0, 100);
TH1D* SeeddeltaPtforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaPtforSimTrackvalidHist", "SeeddeltaPtforSimTrackvalidHist", 150, -3., 3.);
TH1D* SeeddeltaPhiforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaPhiforSimTrackvalidHist", "SeeddeltaPhiforSimTrackvalidHist", 628, -3.14/6, 3.14/6);
TH1D* SeeddeltaEtaforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaEtaforSimTrackvalidHist", "SeeddeltaEtaforSimTrackvalidHist", 200, -1., 1.);
TH1D* SeedPurityforSimTrackvalidHist = (TH1D*) new TH1D("SeedPurityforSimTrackvalidHist", "SeedPurityforSimTrackvalidHist", 20, 0, 2);
TH1D* ChargeCheckforSimTrackvalidHist = (TH1D*) new TH1D("ChargeCheckforSimTrackvalidHist", "ChargeCheckforSimTrackvalidHist", 5, -2.5, 2.5);
TH1D* SeedNumberforSimTrackvalidHist = (TH1D*) new TH1D("SeedNumberforSimTrackvalidHist", "SeedNumberforSimTrackvalidHist", 30, 0, 30);
TH1D* SeedEfficiencyforSimTrackvalidHist = (TH1D*) new TH1D("SeedEfficiencyforSimTrackvalidHist", "SeedEfficiencyforSimTrackvalidHist", 2, 0, 2);
TH1D* SeedNumberforSimTrackinvalidHist = (TH1D*) new TH1D("SeedNumberforSimTrackinvalidHist", "SeedNumberforSimTrackinvalidHist", 20, 0, 20);
TH1D* SeedEfficiencyforSimTrackinvalidHist = (TH1D*) new TH1D("SeedEfficiencyforSimTrackinvalidHist", "SeedEfficiencyforSimTrackinvalidHist", 2, 0, 2);
TH1D* RecBendingLastPhiHist = (TH1D*) new TH1D("RecBendingLastPhiHist", "RecBendingLastPhiHist", 628, -3.14/2, 3.14/2);
TH1D* SeedEfficiencyHist = (TH1D*) new TH1D("SeedEfficiency", "SeedEfficiency", 2, 0, 2);
TH2D* RecBendingPhi2PtHist = new TH2D("RecBendingPhi2PtHist", "RecBendingPhi2PtHist", 2000, -100, 100, 628, -3.14/4, 3.14/4);
TH2D* PtRatoofRecBendingPhiHist = new TH2D("", "", 628, -3.14/4, 3.14/4, 2000, -100, 100);
TObjArray* SimReverseBending = (TObjArray*) new TObjArray();
unsigned int LastSeedNumber = -1;
unsigned int LastSimTrackvalid = 0;
bool LastPassSegmentFilter = false;
bool LastPurityFull = false;
int Nentries = T0->GetEntries();
for(int i = 0; i < Nentries; i++) {
T0->GetEntry(i);
if(debug) cout << "SimTrackId: " << SimTrackId << ", SimTrackType: " << SimTrackType << ", PassSegmentFilter: " << PassSegmentFilter << ", SeedNumber: " << SeedNumber << ", SeedPurity: " << SeedPurity << ", SeedCharge: " << SeedCharge << ", SimTrackCharge: " << SimTrackCharge << ", SimBendingPhi: " << SimBendingPhi << ", RecBendingPhi: " << RecBendingPhi << ", RecBendingLastPhi: " << RecBendingLastPhi << ", RecMomentumPtatRef: " << RecMomentumPtatRef << ", SimMomentumPtatRef: " << SimMomentumPtatRef << ", LastSeedNumber: " << LastSeedNumber << endl;
//if(SimTrackMomentum > 20.0)
//continue;
if(SeedNumber != 0) {
if(SimTrackvalid == 1 && SeedPurity == 1. && PassSegmentFilter == true) {
SeedPtforSimTrackvalidHist->Fill(RecMomentumPtatRef);
SeeddeltaPtforSimTrackvalidHist->Fill((RecMomentumPtatRef-SimMomentumPtatRef)/SimMomentumPtatRef);
SeeddeltaPhiforSimTrackvalidHist->Fill(RecDirectionPhiatRef-SimDirectionPhiatRef);
SeeddeltaEtaforSimTrackvalidHist->Fill(RecDirectionEtaatRef-SimDirectionEtaatRef);
RecBendingPhi2PtHist->Fill(SimMomentumPtatRef*SimTrackCharge, RecBendingPhi);
double PtRato = SimMomentumPtatRef / RecMomentumPtatRef;
if(debug) cout << "PtRato: " << PtRato << ", at RecBendingPhi: " << RecBendingPhi << endl;
PtRatoofRecBendingPhiHist->Fill(RecBendingPhi, PtRato);
RecBendingLastPhiHist->Fill((RecBendingLastPhi == 0. ? 0 : RecBendingLastPhi/fabs(RecBendingLastPhi))*SimTrackCharge);
SeedPurityforSimTrackvalidHist->Fill(SeedPurity);
ChargeCheckforSimTrackvalidHist->Fill(SeedCharge*SimTrackCharge);
/*
if(SeedPurity == 1) {
//SeedPtforSimTrackvalidHist->Fill(RecMomentumPtatRef);
//SeeddeltaPtforSimTrackvalidHist->Fill(RecMomentumPtatRef-SimMomentumPtatRef);
RecBendingPhi2PtHist->Fill(SimMomentumPtatRef*SimTrackCharge, RecBendingPhi);
double PtRato = SimMomentumPtatRef / RecMomentumPtatRef;
if(debug) cout << "PtRato: " << PtRato << ", at RecBendingPhi: " << RecBendingPhi << endl;
PtRatoofRecBendingPhiHist->Fill(RecBendingPhi, PtRato);
RecBendingLastPhiHist->Fill((RecBendingLastPhi == 0. ? 0 : RecBendingLastPhi/fabs(RecBendingLastPhi))*SimTrackCharge);
}
*/
if(SeedCharge*SimTrackCharge == -1) {
if(debug) cout << "R1: " << sqrt(SimBendingEntryPositionX*SimBendingEntryPositionX+SimBendingEntryPositionY*SimBendingEntryPositionY) << ", R2: " << sqrt(SimBendingLeavePositionX*SimBendingLeavePositionX+SimBendingLeavePositionY*SimBendingLeavePositionY) << endl;
TLine* SimSegment = new TLine(SimBendingEntryPositionX, SimBendingEntryPositionY, SimBendingLeavePositionX, SimBendingLeavePositionY);
SimReverseBending->AddLast(SimSegment);
}
LastPurityFull = true;
}
}
else {
if(LastSeedNumber != -1) {
if(LastSimTrackvalid == 1 && LastPassSegmentFilter == true) {
if(debug) cout << "Filling valid track efficiency " << LastSeedNumber << endl;
SeedNumberforSimTrackvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackvalidHist->Fill(LastPurityFull==true?1:0);
}
else {
SeedNumberforSimTrackinvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackinvalidHist->Fill(LastPurityFull==true?1:0);
}
LastPurityFull = false;
}
}
LastPassSegmentFilter = PassSegmentFilter;
LastSeedNumber = SeedNumber;
LastSimTrackvalid = SimTrackvalid;
}
if(LastSeedNumber != -1) {
if(LastSimTrackvalid == 1 && LastPassSegmentFilter == true) {
SeedNumberforSimTrackvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackvalidHist->Fill(LastPurityFull==true?1:0);
}
else {
SeedNumberforSimTrackinvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackinvalidHist->Fill(LastPurityFull == true?1:0);
}
}
TCanvas* SimTrackvalidCanvas = new TCanvas("SimTrackvalidCanvas", "SimTrackvalidCanvas", 800, 600);
SimTrackvalidCanvas->cd();
SimTrackvalidHist->Draw();
string SimTrackvalidCanvasName = FinalOutput + "SimTrackvalid" + OutputPlotNameFix;
SimTrackvalidCanvas->SaveAs(SimTrackvalidCanvasName.c_str());
TCanvas* SeedPtforSimTrackvalidCanvas = new TCanvas("SeedPtforSimTrackvalidCanvas", "SeedPtforSimTrackvalidCanvas", 800, 600);
SeedPtforSimTrackvalidCanvas->cd();
SeedPtforSimTrackvalidHist->Draw();
string SeedPtforSimTrackvalidCanvasName = FinalOutput + "SeedPtforSimTrackvalid" + OutputPlotNameFix;
SeedPtforSimTrackvalidCanvas->SaveAs(SeedPtforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaPtforSimTrackvalidCanvas = new TCanvas("SeeddeltaPtforSimTrackvalidCanvas", "SeeddeltaPtforSimTrackvalidCanvas", 800, 600);
SeeddeltaPtforSimTrackvalidCanvas->cd();
SeeddeltaPtforSimTrackvalidHist->SetStats(1);
gStyle->SetOptFit(0111);
//SeeddeltaPtforSimTrackvalidHist->Fit("gaus", "", "", -1., 1.);
SeeddeltaPtforSimTrackvalidHist->GetXaxis()->SetTitle("(recPt-simPt)/simPt");
SeeddeltaPtforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaPtforSimTrackvalidHist->Draw();
string SeeddeltaPtforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaPtforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaPtforSimTrackvalidCanvas->SaveAs(SeeddeltaPtforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaPhiforSimTrackvalidCanvas = new TCanvas("SeeddeltaPhiforSimTrackvalidCanvas", "SeeddeltaPhiforSimTrackvalidCanvas", 800, 600);
SeeddeltaPhiforSimTrackvalidCanvas->cd();
SeeddeltaPhiforSimTrackvalidHist->SetStats(1);
SeeddeltaPhiforSimTrackvalidHist->GetXaxis()->SetTitle("(recPhi-simPhi)");
SeeddeltaPhiforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaPhiforSimTrackvalidHist->Draw();
string SeeddeltaPhiforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaPhiforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaPhiforSimTrackvalidCanvas->SaveAs(SeeddeltaPhiforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaEtaforSimTrackvalidCanvas = new TCanvas("SeeddeltaEtaforSimTrackvalidCanvas", "SeeddeltaEtaforSimTrackvalidCanvas", 800, 600);
SeeddeltaEtaforSimTrackvalidCanvas->cd();
SeeddeltaEtaforSimTrackvalidHist->SetStats(1);
SeeddeltaEtaforSimTrackvalidHist->GetXaxis()->SetTitle("(recEta-simEta)");
SeeddeltaEtaforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaEtaforSimTrackvalidHist->Draw();
string SeeddeltaEtaforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaEtaforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaEtaforSimTrackvalidCanvas->SaveAs(SeeddeltaEtaforSimTrackvalidCanvasName.c_str());
TCanvas* SeedPurityforSimTrackvalidCanvas = new TCanvas("SeedPurityforSimTrackvalidCanvas", "SeedPurityforSimTrackvalidCanvas", 800, 600);
SeedPurityforSimTrackvalidCanvas->cd();
SeedPurityforSimTrackvalidHist->Draw();
string SeedPurityforSimTrackvalidCanvasName = FinalOutput + "SeedPurityforSimTrackvalid" + OutputPlotNameFix;
SeedPurityforSimTrackvalidCanvas->SaveAs(SeedPurityforSimTrackvalidCanvasName.c_str());
TCanvas* ChargeCheckforSimTrackvalidCanvas = new TCanvas("ChargeCheckforSimTrackvalidCanvas", "ChargeCheckforSimTrackvalidCanvas", 800, 600);
ChargeCheckforSimTrackvalidCanvas->cd();
double HistEntries = ChargeCheckforSimTrackvalidHist->GetEntries() / 100.;
ChargeCheckforSimTrackvalidHist->Scale(1./HistEntries);
ChargeCheckforSimTrackvalidHist->GetXaxis()->SetTitle("simCharge*recCharge");
ChargeCheckforSimTrackvalidHist->GetXaxis()->CenterTitle(1);
ChargeCheckforSimTrackvalidHist->GetYaxis()->SetTitle("fraction %");
ChargeCheckforSimTrackvalidHist->GetYaxis()->CenterTitle(1);
ChargeCheckforSimTrackvalidHist->Draw();
string ChargeCheckforSimTrackvalidCanvasName = FinalOutput + "ChargeCheckforSimTrackvalid" + OutputPlotNameFix;
ChargeCheckforSimTrackvalidCanvas->SaveAs(ChargeCheckforSimTrackvalidCanvasName.c_str());
TCanvas* SeedNumberforSimTrackvalidCanvas = new TCanvas("SeedNumberforSimTrackvalidCanvas", "SeedNumberforSimTrackvalidCanvas", 800, 600);
SeedNumberforSimTrackvalidCanvas->cd();
SeedNumberforSimTrackvalidHist->Draw();
string SeedNumberforSimTrackvalidCanvasName = FinalOutput + "SeedNumberforSimTrackvalid" + OutputPlotNameFix;
SeedNumberforSimTrackvalidCanvas->SaveAs(SeedNumberforSimTrackvalidCanvasName.c_str());
TCanvas* SeedEfficiencyforSimTrackvalidCanvas = new TCanvas("SeedEfficiencyforSimTrackvalidCanvas", "SeedEfficiencyforSimTrackvalidCanvas", 800, 600);
SeedEfficiencyforSimTrackvalidCanvas->cd();
SeedEfficiencyforSimTrackvalidHist->Draw();
string SeedEfficiencyforSimTrackvalidCanvasName = FinalOutput + "SeedEfficiencyforSimTrackvalid" + OutputPlotNameFix;
SeedEfficiencyforSimTrackvalidCanvas->SaveAs(SeedEfficiencyforSimTrackvalidCanvasName.c_str());
TCanvas* SeedNumberforSimTrackinvalidCanvas = new TCanvas("SeedNumberforSimTrackinvalidCanvas", "SeedNumberforSimTrackinvalidCanvas", 800, 600);
SeedNumberforSimTrackinvalidCanvas->cd();
SeedNumberforSimTrackinvalidHist->Draw();
string SeedNumberforSimTrackinvalidCanvasName = FinalOutput + "SeedNumberforSimTrackinvalid" + OutputPlotNameFix;
SeedNumberforSimTrackinvalidCanvas->SaveAs(SeedNumberforSimTrackinvalidCanvasName.c_str());
TCanvas* SeedEfficiencyforSimTrackinvalidCanvas = new TCanvas("SeedEfficiencyforSimTrackinvalidCanvas", "SeedEfficiencyforSimTrackinvalidCanvas", 800, 600);
SeedEfficiencyforSimTrackinvalidCanvas->cd();
SeedEfficiencyforSimTrackinvalidHist->Draw();
string SeedEfficiencyforSimTrackinvalidCanvasName = FinalOutput + "SeedEfficiencyforSimTrackinvalid" + OutputPlotNameFix;
SeedEfficiencyforSimTrackinvalidCanvas->SaveAs(SeedEfficiencyforSimTrackinvalidCanvasName.c_str());
double SeedEfficiencyforSimTrackinvalid = 100. * SeedEfficiencyforSimTrackinvalidHist->GetMean();
double SeedEfficiencyforSimTrackvalid = 100. * SeedEfficiencyforSimTrackvalidHist->GetMean();
SeedEfficiencyHist->SetBinContent(1, SeedEfficiencyforSimTrackinvalid);
SeedEfficiencyHist->SetBinContent(2, SeedEfficiencyforSimTrackvalid);
SeedEfficiencyHist->GetXaxis()->SetBinLabel(1, "for invalid simTrack");
SeedEfficiencyHist->GetXaxis()->SetBinLabel(2, "for valid simTrack");
TCanvas* SeedEfficiencyCanvas = new TCanvas("SeedEfficiencyCanvas", "SeedEfficiencyCanvas", 800, 600);
SeedEfficiencyCanvas->cd();
SeedEfficiencyHist->GetYaxis()->SetTitle("Efficiency %");
SeedEfficiencyHist->GetYaxis()->CenterTitle(1);
SeedEfficiencyHist->SetMarkerStyle(3);
SeedEfficiencyHist->SetMarkerSize(3);
SeedEfficiencyHist->Draw("P");
string SeedEfficiencyCanvasName = FinalOutput + "SeedEfficiency" + OutputPlotNameFix;
SeedEfficiencyCanvas->SaveAs(SeedEfficiencyCanvasName.c_str());
TCanvas* RecBendingPhi2PtCanvas = new TCanvas("RecBendingPhi2PtCanvas", "RecBendingPhi2PtCanvas", 800, 600);
RecBendingPhi2PtCanvas->cd();
RecBendingPhi2PtHist->Draw();
string RecBendingPhi2PtCanvasName = FinalOutput + "RecBendingPhi2Pt" + OutputPlotNameFix;
RecBendingPhi2PtCanvas->SaveAs(RecBendingPhi2PtCanvasName.c_str());
TCanvas* PtRatoofRecBendingPhiCanvas = new TCanvas("PtRatoofRecBendingPhiCanvas", "PtRatoofRecBendingPhiCanvas", 800, 600);
PtRatoofRecBendingPhiCanvas->cd();
PtRatoofRecBendingPhiHist->Draw();
string PtRatoofRecBendingPhiCanvasName = FinalOutput + "PtRatoofRecBendingPhi" + OutputPlotNameFix;
PtRatoofRecBendingPhiCanvas->SaveAs(PtRatoofRecBendingPhiCanvasName.c_str());
TCanvas* RecBendingLastPhiCanvas = new TCanvas("RecBendingLastPhiCanvas", "RecBendingLastPhiCanvas", 800, 600);
RecBendingLastPhiCanvas->cd();
RecBendingLastPhiHist->Draw();
string RecBendingLastPhiCanvasName = FinalOutput + "RecBendingLastPhi" + OutputPlotNameFix;
RecBendingLastPhiCanvas->SaveAs(RecBendingLastPhiCanvasName.c_str());
Int_t linsav = gStyle->GetLineWidth();
gStyle->SetLineWidth(2);
TCanvas* SimReverseBendingCanvas = new TCanvas("SimReverseBendingCanvas", "SimReverseBendingCanvas", 800, 800);
SimReverseBendingCanvas->cd();
TPad* SimReverseBendingPad = new TPad("SimReverseBendingPad", "SimReverseBendingPad", 0, 0, 1, 1);
SimReverseBendingPad->Draw();
SimReverseBendingPad->cd();
SimReverseBendingPad->Range(-800, -800, 800, 800);
unsigned int segmentNumber = SimReverseBending->GetEntries();
cout << "Number of segments: " << segmentNumber << endl;
for(unsigned int j = 0; j < segmentNumber; j++) {
((TLine*)(SimReverseBending->At(j)))->Print();
((TLine*)(SimReverseBending->At(j)))->Draw("SAME");
}
string SimReverseBendingCanvasName = FinalOutput + "SimReverseBending" + OutputPlotNameFix;
SimReverseBendingCanvas->SaveAs(SimReverseBendingCanvasName.c_str());
}
void limit() {
//This program demonstrates the computation of 95 % C.L. limits.
//It uses a set of randomly created histograms.
//
//Author: [email protected] on 21.08.02
// Create a new canvas.
TCanvas *c1 = new TCanvas("c1","Dynamic Filling Example",200,10,700,500);
c1->SetFillColor(42);
// Create some histograms
TH1D* background = new TH1D("background","The expected background",30,-4,4);
TH1D* signal = new TH1D("signal","the expected signal",30,-4,4);
TH1D* data = new TH1D("data","some fake data points",30,-4,4);
background->SetFillColor(48);
signal->SetFillColor(41);
data->SetMarkerStyle(21);
data->SetMarkerColor(kBlue);
background->Sumw2(); // needed for stat uncertainty
signal->Sumw2(); // needed for stat uncertainty
// Fill histograms randomly
TRandom2 r;
Float_t bg,sig,dt;
for (Int_t i = 0; i < 25000; i++) {
bg = r.Gaus(0,1);
sig = r.Gaus(1,.2);
background->Fill(bg,0.02);
signal->Fill(sig,0.001);
}
for (Int_t i = 0; i < 500; i++) {
dt = r.Gaus(0,1);
data->Fill(dt);
}
THStack *hs = new THStack("hs","Signal and background compared to data...");
hs->Add(background);
hs->Add(signal);
hs->Draw("hist");
data->Draw("PE1,Same");
c1->Modified();
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(6);
c1->GetFrame()->SetBorderMode(-1);
c1->Modified();
c1->Update();
gSystem->ProcessEvents();
// Compute the limits
cout << "Computing limits... " << endl;
TLimitDataSource* mydatasource = new TLimitDataSource(signal,background,data);
TConfidenceLevel *myconfidence = TLimit::ComputeLimit(mydatasource,50000);
cout << "CLs : " << myconfidence->CLs() << endl;
cout << "CLsb : " << myconfidence->CLsb() << endl;
cout << "CLb : " << myconfidence->CLb() << endl;
cout << "< CLs > : " << myconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << myconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << myconfidence->GetExpectedCLb_b() << endl;
// Add stat uncertainty
cout << endl << "Computing limits with stat systematics... " << endl;
TConfidenceLevel *mystatconfidence = TLimit::ComputeLimit(mydatasource,50000,true);
cout << "CLs : " << mystatconfidence->CLs() << endl;
cout << "CLsb : " << mystatconfidence->CLsb() << endl;
cout << "CLb : " << mystatconfidence->CLb() << endl;
cout << "< CLs > : " << mystatconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << mystatconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << mystatconfidence->GetExpectedCLb_b() << endl;
// Add some systematics
cout << endl << "Computing limits with systematics... " << endl;
TVectorD errorb(2);
TVectorD errors(2);
TObjArray* names = new TObjArray();
TObjString name1("bg uncertainty");
TObjString name2("sig uncertainty");
names->AddLast(&name1);
names->AddLast(&name2);
errorb[0]=0.05; // error source 1: 5%
errorb[1]=0; // error source 2: 0%
errors[0]=0; // error source 1: 0%
errors[1]=0.01; // error source 2: 1%
TLimitDataSource* mynewdatasource = new TLimitDataSource();
mynewdatasource->AddChannel(signal,background,data,&errors,&errorb,names);
TConfidenceLevel *mynewconfidence = TLimit::ComputeLimit(mynewdatasource,50000,true);
cout << "CLs : " << mynewconfidence->CLs() << endl;
cout << "CLsb : " << mynewconfidence->CLsb() << endl;
cout << "CLb : " << mynewconfidence->CLb() << endl;
cout << "< CLs > : " << mynewconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << mynewconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << mynewconfidence->GetExpectedCLb_b() << endl;
// show canonical -2lnQ plots in a new canvas
// - The histogram of -2lnQ for background hypothesis (full)
// - The histogram of -2lnQ for signal and background hypothesis (dashed)
TCanvas *c2 = new TCanvas("c2");
myconfidence->Draw();
// clean up (except histograms and canvas)
delete myconfidence;
delete mydatasource;
delete mystatconfidence;
delete mynewconfidence;
delete mynewdatasource;
}
void MakeADRecoParamEntry(AliRecoParam::EventSpecie_t defaultEventSpecie=AliRecoParam::kLowMult, const char *outputCDB = "local://$ALICE_ROOT/OCDB") {
//========================================================================
//
// Steering macro for AD reconstruction parameters
//
// Author: Michal Broz
//
//========================================================================
const char* macroname = "MakeADRecoParam.C";
// Activate CDB storage and load geometry from CDB
AliCDBManager* cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(outputCDB);
cdb->SetRun(0);
TObjArray *recoParamArray = new TObjArray();
{
AliADRecoParam * ADRecoParam = new AliADRecoParam;
ADRecoParam->SetEventSpecie(AliRecoParam::kCosmic);
ADRecoParam->SetStartClock(0);
ADRecoParam->SetEndClock(20);
ADRecoParam->SetNPreClocks(1);
ADRecoParam->SetNPostClocks(10);
ADRecoParam->SetTimeWindowBBALow(-2.5);
ADRecoParam->SetTimeWindowBBAUp(2.5);
ADRecoParam->SetTimeWindowBGALow(-4.0);
ADRecoParam->SetTimeWindowBGAUp(4.0);
ADRecoParam->SetTimeWindowBBCLow(-1.5);
ADRecoParam->SetTimeWindowBBCUp(1.5);
ADRecoParam->SetTimeWindowBGCLow(-2.0);
ADRecoParam->SetTimeWindowBGCUp(2.0);
ADRecoParam->SetAdcThresHold(5);
ADRecoParam->SetMaxResid(1.5);
ADRecoParam->SetResidRise(0.02);
recoParamArray->AddLast(ADRecoParam);
}
{
AliADRecoParam * ADRecoParam = new AliADRecoParam;
ADRecoParam->SetStartClock(0);
ADRecoParam->SetEndClock(20);
ADRecoParam->SetNPreClocks(1);
ADRecoParam->SetNPostClocks(10);
ADRecoParam->SetTimeWindowBBALow(-2.5);
ADRecoParam->SetTimeWindowBBAUp(2.5);
ADRecoParam->SetTimeWindowBGALow(-4.0);
ADRecoParam->SetTimeWindowBGAUp(4.0);
ADRecoParam->SetTimeWindowBBCLow(-1.5);
ADRecoParam->SetTimeWindowBBCUp(1.5);
ADRecoParam->SetTimeWindowBGCLow(-2.0);
ADRecoParam->SetTimeWindowBGCUp(2.0);
ADRecoParam->SetAdcThresHold(5);
ADRecoParam->SetMaxResid(1.5);
ADRecoParam->SetResidRise(0.02);
ADRecoParam->SetEventSpecie(AliRecoParam::kLowMult);
recoParamArray->AddLast(ADRecoParam);
}
{
AliADRecoParam * ADRecoParam = new AliADRecoParam;
ADRecoParam->SetStartClock(9);
ADRecoParam->SetEndClock(11);
ADRecoParam->SetNPostClocks(6);
ADRecoParam->SetTimeWindowBBALow(-2.5);
ADRecoParam->SetTimeWindowBBAUp(2.5);
ADRecoParam->SetTimeWindowBGALow(-4.0);
ADRecoParam->SetTimeWindowBGAUp(4.0);
ADRecoParam->SetTimeWindowBBCLow(-1.5);
ADRecoParam->SetTimeWindowBBCUp(1.5);
ADRecoParam->SetTimeWindowBGCLow(-2.0);
ADRecoParam->SetTimeWindowBGCUp(2.0);
ADRecoParam->SetAdcThresHold(5);
ADRecoParam->SetMaxResid(1.5);
ADRecoParam->SetResidRise(0.02);
ADRecoParam->SetEventSpecie(AliRecoParam::kHighMult);
recoParamArray->AddLast(ADRecoParam);
}
// Set the defaultEventSpecie
Bool_t defaultIsSet = kFALSE;
for(Int_t i =0; i < recoParamArray->GetEntriesFast(); i++) {
AliDetectorRecoParam *param = (AliDetectorRecoParam *)recoParamArray->UncheckedAt(i);
if (!param) continue;
if (defaultEventSpecie & param->GetEventSpecie()) {
param->SetAsDefault();
defaultIsSet = kTRUE;
}
}
if (!defaultIsSet) {
Error(macroname,"The default reconstruction parameters are not set! Exiting...");
return;
}
// save in CDB storage
AliCDBMetaData *md= new AliCDBMetaData();
md->SetResponsible("Michal Broz");
md->SetComment("Reconstruction parameters for AD");
md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
md->SetBeamPeriod(0);
AliCDBId id("AD/Calib/RecoParam", 0, AliCDBRunRange::Infinity());
cdb->Put(recoParamArray, id, md);
return;
}
Bool_t AliCFSingleTrackTask(
const Bool_t useGrid = 1,
const Bool_t readAOD = 0,
const Bool_t readTPCTracks = 0,
const char * kTagXMLFile="wn.xml" // XML file containing tags
)
{
TBenchmark benchmark;
benchmark.Start("AliSingleTrackTask");
AliLog::SetGlobalDebugLevel(0);
Load() ; //load the required libraries
TChain * analysisChain ;
if (useGrid) { //data located on AliEn
TGrid::Connect("alien://") ; // Create an AliRunTagCuts and an AliEventTagCuts Object
// and impose some selection criteria
AliRunTagCuts *runCuts = new AliRunTagCuts();
AliEventTagCuts *eventCuts = new AliEventTagCuts();
AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
eventCuts->SetMultiplicityRange(0,2000);
// Create an AliTagAnalysis Object and chain the tags
AliTagAnalysis *tagAna = new AliTagAnalysis();
if (readAOD) tagAna->SetType("AOD"); //for aliroot > v4-05
else tagAna->SetType("ESD"); //for aliroot > v4-05
TAlienCollection *coll = TAlienCollection::Open(kTagXMLFile);
TGridResult *tagResult = coll->GetGridResult("",0,0);
tagResult->Print();
tagAna->ChainGridTags(tagResult);
// Create a new esd chain and assign the chain that is returned by querying the tags
analysisChain = tagAna->QueryTags(runCuts,lhcCuts,detCuts,eventCuts);
}
else {// local data
//here put your input data path
printf("\n\nRunning on local file, please check the path\n\n");
if (readAOD) {
analysisChain = new TChain("aodTree");
analysisChain->Add("your_data_path/001/AliAOD.root");
analysisChain->Add("your_data_path/002/AliAOD.root");
}
else {
analysisChain = new TChain("esdTree");
analysisChain->Add("your_data_path/001/AliESDs.root");
analysisChain->Add("your_data_path/002/AliESDs.root");
}
}
Info("AliCFSingleTrackTask",Form("CHAIN HAS %d ENTRIES",(Int_t)analysisChain->GetEntries()));
//CONTAINER DEFINITION
Info("AliCFSingleTrackTask","SETUP CONTAINER");
//the sensitive variables (2 in this example), their indices
UInt_t ipt = 0;
UInt_t iy = 1;
//Setting up the container grid...
UInt_t nstep = 4 ; //number of selection steps MC
const Int_t nvar = 2 ; //number of variables on the grid:pt,y
const Int_t nbin1 = 8 ; //bins in pt
const Int_t nbin2 = 8 ; //bins in y
//arrays for the number of bins in each dimension
Int_t iBin[nvar];
iBin[0]=nbin1;
iBin[1]=nbin2;
//arrays for lower bounds :
Double_t *binLim1=new Double_t[nbin1+1];
Double_t *binLim2=new Double_t[nbin2+1];
//values for bin lower bounds
for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Double_t)ptmin + (ptmax-ptmin)/nbin1*(Double_t)i ;
for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)ymin + (ymax-ymin) /nbin2*(Double_t)i ;
//one "container" for MC
AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin);
//setting the bin limits
container -> SetBinLimits(ipt,binLim1);
container -> SetBinLimits(iy,binLim2);
container -> SetVarTitle(ipt,"pt");
container -> SetVarTitle(iy, "y");
container -> SetStepTitle(0, "generated");
container -> SetStepTitle(1, "in acceptance");
container -> SetStepTitle(2, "reconstructed");
container -> SetStepTitle(3, "after PID");
// SET TLIST FOR QA HISTOS
TList* qaList = new TList();
//CREATE THE CUTS -----------------------------------------------
//Event-level cuts:
AliCFEventRecCuts* evtRecCuts = new AliCFEventRecCuts("evtRecCuts","Rec-event cuts");
// evtRecCuts->SetUseTPCVertex();
// evtRecCuts->SetRequireVtxCuts(kTRUE);
// evtRecCuts->SetVertexNContributors(-2,5);
evtRecCuts->SetQAOn(qaList);
// Gen-Level kinematic cuts
AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
mcKineCuts->SetPtRange(ptmin,ptmax);
mcKineCuts->SetRapidityRange(ymin,ymax);
mcKineCuts->SetChargeMC(charge);
mcKineCuts->SetQAOn(qaList);
//Particle-Level cuts:
AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
mcGenCuts->SetRequireIsPrimary();
mcGenCuts->SetRequirePdgCode(PDG,/*absolute=*/kTRUE);
mcGenCuts->SetQAOn(qaList);
//Acceptance Cuts
AliCFAcceptanceCuts *mcAccCuts = new AliCFAcceptanceCuts("mcAccCuts","MC acceptance cuts");
mcAccCuts->SetMinNHitITS(mintrackrefsITS);
mcAccCuts->SetMinNHitTPC(mintrackrefsTPC);
mcAccCuts->SetQAOn(qaList);
// Rec-Level kinematic cuts
AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
recKineCuts->SetPtRange(ptmin,ptmax);
recKineCuts->SetRapidityRange(ymin,ymax);
recKineCuts->SetChargeRec(charge);
recKineCuts->SetQAOn(qaList);
AliCFTrackQualityCuts *recQualityCuts = new AliCFTrackQualityCuts("recQualityCuts","rec-level quality cuts");
if (!readAOD) {
// recQualityCuts->SetMinNClusterTRD(0);
// recQualityCuts->SetMaxChi2PerClusterTRD(10.);
}
recQualityCuts->SetStatus(AliESDtrack::kTPCrefit);
recQualityCuts->SetQAOn(qaList);
AliCFTrackIsPrimaryCuts *recIsPrimaryCuts = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts","rec-level isPrimary cuts");
if (readAOD) recIsPrimaryCuts->SetAODType(AliAODTrack::kPrimary);
else recIsPrimaryCuts->SetMaxNSigmaToVertex(3);
recIsPrimaryCuts->SetQAOn(qaList);
AliCFTrackCutPid* cutPID = new AliCFTrackCutPid("cutPID","ESD_PID") ;
int n_species = AliPID::kSPECIES ;
Double_t* prior = new Double_t[n_species];
prior[0] = 0.0244519 ;
prior[1] = 0.0143988 ;
prior[2] = 0.805747 ;
prior[3] = 0.0928785 ;
prior[4] = 0.0625243 ;
cutPID->SetPriors(prior);
cutPID->SetProbabilityCut(0.0);
if (readTPCTracks) cutPID->SetDetectors("TPC");
else cutPID->SetDetectors("ALL");
if (readAOD) cutPID->SetAODmode(kTRUE );
else cutPID->SetAODmode(kFALSE);
switch(TMath::Abs(PDG)) {
case 11 : cutPID->SetParticleType(AliPID::kElectron, kTRUE); break;
case 13 : cutPID->SetParticleType(AliPID::kMuon , kTRUE); break;
case 211 : cutPID->SetParticleType(AliPID::kPion , kTRUE); break;
case 321 : cutPID->SetParticleType(AliPID::kKaon , kTRUE); break;
case 2212 : cutPID->SetParticleType(AliPID::kProton , kTRUE); break;
default : printf("UNDEFINED PID\n"); break;
}
cutPID->SetQAOn(qaList);
printf("CREATE EVENT LEVEL CUTS\n");
TObjArray* evtList = new TObjArray(0) ;
// evtList->AddLast(evtRecCuts);
printf("CREATE MC KINE CUTS\n");
TObjArray* mcList = new TObjArray(0) ;
mcList->AddLast(mcKineCuts);
mcList->AddLast(mcGenCuts);
printf("CREATE ACCEPTANCE CUTS\n");
TObjArray* accList = new TObjArray(0) ;
accList->AddLast(mcAccCuts);
printf("CREATE RECONSTRUCTION CUTS\n");
TObjArray* recList = new TObjArray(0) ;
recList->AddLast(recKineCuts);
recList->AddLast(recQualityCuts);
recList->AddLast(recIsPrimaryCuts);
printf("CREATE PID CUTS\n");
TObjArray* fPIDCutList = new TObjArray(0) ;
fPIDCutList->AddLast(cutPID);
//CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
printf("CREATE INTERFACE AND CUTS\n");
AliCFManager* man = new AliCFManager() ;
man->SetNStepEvent(1);
man->SetEventCutsList(0,evtList);
man->SetParticleContainer(container);
man->SetParticleCutsList(0,mcList);
man->SetParticleCutsList(1,accList);
man->SetParticleCutsList(2,recList);
man->SetParticleCutsList(3,fPIDCutList);
//CREATE THE TASK
printf("CREATE TASK\n");
// create the task
AliCFSingleTrackTask *task = new AliCFSingleTrackTask("AliSingleTrackTask");
task->SetCFManager(man); //here is set the CF manager
task->SetQAList(qaList);
if (readAOD) task->SetReadAODData() ;
if (readTPCTracks) task->SetReadTPCTracks();
//SETUP THE ANALYSIS MANAGER TO READ INPUT CHAIN AND WRITE DESIRED OUTPUTS
printf("CREATE ANALYSIS MANAGER\n");
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
if (useGrid) mgr->SetAnalysisType(AliAnalysisManager::kGridAnalysis);
else mgr->SetAnalysisType(AliAnalysisManager::kLocalAnalysis);
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
AliInputEventHandler* dataHandler ;
if (readAOD) dataHandler = new AliAODInputHandler();
else dataHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(dataHandler);
// Create and connect containers for input/output
//------ input data ------
AliAnalysisDataContainer *cinput0 = mgr->CreateContainer("cchain0",TChain::Class(),AliAnalysisManager::kInputContainer);
// ----- output data -----
//slot 0 : default output tree (by default handled by AliAnalysisTaskSE)
AliAnalysisDataContainer *coutput0 = mgr->CreateContainer("ctree0", TTree::Class(),AliAnalysisManager::kOutputContainer,"output.root");
//now comes user's output objects :
// output TH1I for event counting
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist0", TH1I::Class(),AliAnalysisManager::kOutputContainer,"output.root");
// output Correction Framework Container (for acceptance & efficiency calculations)
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("ccontainer0", AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,"output.root");
// output QA histograms
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("clist0", TList::Class(),AliAnalysisManager::kOutputContainer,"output.root");
cinput0->SetData(analysisChain);
mgr->AddTask(task);
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,0,coutput0);
mgr->ConnectOutput(task,1,coutput1);
mgr->ConnectOutput(task,2,coutput2);
mgr->ConnectOutput(task,3,coutput3);
printf("READY TO RUN\n");
//RUN !!!
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local",analysisChain);
}
benchmark.Stop("AliSingleTrackTask");
benchmark.Show("AliSingleTrackTask");
return kTRUE ;
}
void bfcread_tagsBranch(
const char *MainFile="/afs/rhic.bnl.gov/star/data/samples/gstar.tags.root",
Int_t printEvent=1,
const char *fname="qa_tags.out",
Int_t fullPrint=0)
{
// start timer
TStopwatch timer;
timer.Start();
cout << endl << endl;
cout << " bfcread_tagsBranch.C: input file = " << MainFile << endl;
cout << " bfcread_tagsBranch.C: print event # " << printEvent << endl;
cout << " bfcread_tagsBranch.C: output file = " << fname << endl;
cout << " bfcread_tagsBranch.C: full printout = " << fullPrint << endl;
cout << endl;
ofstream fout(fname);
fout << endl << endl;
fout << " bfcread_tagsBranch.C: input file = " << MainFile << endl;
fout << " bfcread_tagsBranch.C: print evt# = " << printEvent << endl;
fout << " bfcread_tagsBranch.C: output file = " << fname << endl;
fout << " bfcread_tagsBranch.C: full printout = " << fullPrint << endl;
fout << endl;
TFile *file = TFile::Open(MainFile);
TTree *tree = (TTree*)file->Get("Tag");
cout <<" read file: " << file->GetName() << endl << endl;
Int_t nEntries = tree->GetEntries();
cout << " Total # events = " << nEntries << endl;
TObjArray *leaves = tree->GetListOfLeaves();
Int_t nLeaves = leaves->GetEntriesFast();
cout << " Total # leaves = " << nLeaves << endl;
TString *tName = new TString(" ");
TNamed *tableName=0;
TObjArray *tagTable = new TObjArray;
Int_t tableCount = 0;
Int_t *tableIndex = new Int_t[nLeaves];
Int_t tagCount = 0;
TBranch *branch=0;
TLeaf *leaf=0;
Int_t ndim =0;
//count number of tag tables encoded in the TTree branch names
for (Int_t l=0;l<nLeaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
tagCount+=leaf->GetNdata();
branch = leaf->GetBranch();
cout << "leaf # " << l << " br name = " <<
branch->GetName() << endl;
//new tag table name
if ( strstr(branch->GetName(), tName->Data()) == 0 ) {
tName = new TString(branch->GetName());
tName->Resize(tName->Index("."));
//the tableName is encoded in the branch Name before the "."
tableName = new TNamed(tName->Data(),"Tag");
tagTable->AddLast(tableName);
tableCount++;
}
tableIndex[l]=tableCount-1;
}
cout << endl << " Total num tables(branches),tags = "
<< tableCount << " " << tagCount << endl << endl;
Int_t *countTagsTable = new Int_t[tableCount];
Int_t *countLeavesTable = new Int_t[tableCount];
Float_t *sumTagsLeaf = new Float_t[nLeaves];
Int_t *countTagsLeaf = new Int_t[nLeaves];
// Now loop over leaves (to get values of tags)
Int_t setBranch = -1;
Int_t nowBranch = -1;
for (Int_t l=0;l<nLeaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
branch = leaf->GetBranch();
ndim = leaf->GetNdata();
nowBranch = tableIndex[l];
//cout << " nowbranch, setBranch = " <<
// nowBranch << ", "<< setBranch << endl;
Float_t RtableIndex=tableIndex[l];
if (nowBranch != setBranch){
setBranch=nowBranch;
cout << " QAInfo: branch ";
cout.width(2);
cout << tableIndex[l] << " = ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(tableIndex[l]))->GetName();
cout << endl;
fout << " QAInfo: branch ";
fout.width(2);
fout << RtableIndex << " = ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(tableIndex[l]))->GetName();
fout << endl;
}
countTagsTable[tableIndex[l]]+=leaf->GetNdata();
countLeavesTable[tableIndex[l]]++;
countTagsLeaf[l]+=ndim;
Float_t Rl=l;
Float_t Rndim=ndim;
cout << " QAInfo: leaf ";
cout.width(3);
cout << l << " has ";
cout.width(1);
cout << ndim << " tags:";
cout << endl;
fout << " QAInfo: leaf ";
fout.width(3);
fout << Rl << " has ";
fout.width(1);
fout << Rndim << " tags:";
fout << endl;
// loop over all events in each leaf
for (Int_t nev=0; nev<nEntries; nev++) {
branch->GetEntry(nev);
// loop over all tags in each leaf for each event
for (Int_t itag=0;itag<ndim;itag++) {
Int_t ik = nev+1;
if (ik==printEvent) {
cout << " QAInfo: " << leaf->GetName();
if (ndim>1) cout << '['<<itag<<']';
cout << " = " << leaf->GetValue(itag) << endl;
fout << " QAInfo: " << leaf->GetName();
if (ndim>1) fout << '['<<itag<<']';
fout << " = " << leaf->GetValue(itag) << endl;
}
sumTagsLeaf[l]+=leaf->GetValue(itag);
}
}
}
cout << endl << endl;
fout << endl << endl;
if (fullPrint == 1){
// loop over leaves again for printout at end
for (Int_t m=0; m<nLeaves; m++){
leaf = (TLeaf*)leaves->UncheckedAt(m);
branch = leaf->GetBranch();
ndim = leaf->GetNdata();
cout << " QAInfo: branch ";
cout.width(2);
cout << tableIndex[m] << " = ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(tableIndex[m]))->GetName();
cout << ", leaf ";
cout.width(3);
cout << m << " = ";
cout.width(24);
cout << leaf->GetName();
cout << ", #tags = ";
cout.width(1);
cout << ndim;
cout << endl;
Float_t RtableIndex=tableIndex[m];
Float_t Rm=m;
Float_t Rndim=ndim;
fout << " QAInfo: branch ";
fout.width(2);
fout << RtableIndex << " = ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(tableIndex[m]))->GetName();
fout << ", leaf ";
fout.width(3);
fout << Rm << " = ";
fout.width(24);
fout << leaf->GetName();
fout << ", #tags = ";
fout.width(1);
fout << Rndim;
fout << endl;
}
}
cout << endl << endl;
fout << endl << endl;
// loop over leaves again for printout at end of averages
cout << " QAInfo: each leaf's avg over all tags,evts: " << endl;
fout << " QAInfo: each leaf's avg over all tags,evts: " << endl;
for (Int_t m=0; m<nLeaves; m++){
leaf = (TLeaf*)leaves->UncheckedAt(m);
sumTagsLeaf[m]/=countTagsLeaf[m]*nEntries;
cout << " QAInfo: avg leaf #";
cout.width(2);
cout << m << ", ";
cout.width(23);
cout << leaf->GetName() << " = ";
cout.width(12);
cout << sumTagsLeaf[m];
cout << endl;
Float_t Rm=m;
fout << " QAInfo: avg leaf #";
fout.width(2);
fout << Rm << ", ";
fout.width(23);
fout << leaf->GetName() << " = ";
fout.width(12);
fout << sumTagsLeaf[m];
fout << endl;
}
cout << endl << endl;
fout << endl << endl;
// loop over all tables
for (Int_t m=0; m<tableCount; m++){
cout << " QAInfo: branch(table) ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(m))->GetName() << " has ";
cout.width(4);
cout << countLeavesTable[m] << " leaves,";
cout.width(4);
cout << countTagsTable[m] << " tags" << endl;
Float_t RcountLeavesTable=countLeavesTable[m];
Float_t RcountTagsTable=countTagsTable[m];
fout << " QAInfo: branch(table) ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(m))->GetName() << " has ";
fout.width(4);
fout << RcountLeavesTable << " leaves,";
fout.width(4);
fout << RcountTagsTable << " tags" << endl;
}
cout << endl << endl;
fout << endl << endl;
Float_t RnEntries=nEntries;
Float_t RtableCount=tableCount;
Float_t RnLeaves=nLeaves;
Float_t RtagCount=tagCount;
cout << " QAInfo: tot num events = " << nEntries << endl;
fout << " QAInfo: tot num events = " << RnEntries << endl;
cout << " QAInfo: tot num branches = " << tableCount << endl;
fout << " QAInfo: tot num branches = " << RtableCount << endl;
cout << " QAInfo: tot num leaves = " << nLeaves << endl;
fout << " QAInfo: tot num leaves = " << RnLeaves << endl;
cout << " QAInfo: tot num tags = " << tagCount << endl;
fout << " QAInfo: tot num tags = " << RtagCount << endl;
// stop timer and print results
timer.Stop();
cout<< endl << endl <<"RealTime="<<timer.RealTime()<<
" seconds, CpuTime="<<timer.CpuTime()<<" seconds"<<endl;
//cleanup
file->Close();
fout.close();
}
