void CountPrimaries(TH1F *hMultCount) { if (hMultCount==0) hMultCount = new TH1F("mult","averaged multiplicity (charg. prim)",80,-4.,4.); AliRunLoader *rl = AliRunLoader::Open("galice.root"); rl->SetKineFileName("Kinematics.root"); rl->LoadHeader(); rl->LoadKinematics(); Int_t nEvents = rl->GetNumberOfEvents(); cout<< "N events "<<nEvents<<endl; for(Int_t iEv=0; iEv<nEvents; iEv++){ rl->GetEvent(iEv); AliStack *s = rl->Stack(); for(Int_t iP=0; iP<s->GetNtrack(); iP++ ){ TParticle *p = s->Particle(iP); if (!(s->IsPhysicalPrimary(iP))) continue; Float_t eta = p->Eta(); if (p->Pt()>0.06) { hMultCount->Fill(eta); } } } hMultCount->DrawCopy(); rl->UnloadHeader(); rl->UnloadKinematics(); delete rl; }
void plots() { gSystem->Load("libEVGEN"); // Needs to be! AliRunLoader* rl = AliRunLoader::Open("galice.root"); rl->LoadKinematics(); rl->LoadHeader(); // 4pi histograms TH1* hM = new TH1D("hM", "DIME #rho#rho;M_{4#pi} #(){GeV/#it{c}^{2}}", 100, 1.0, 3.0); TH1* hPt = new TH1D("hPt", "DIME #rho#rho;p_{T}#(){4#pi} #(){GeV/#it{c}}", 100, 0.0, 3.0); // pi+- histograms TH1* hPt1 = new TH1D("hPt1", "DIME #rho#rho;p_{T}#(){#pi^{#pm}} #(){Gev/#it{c}}", 100, 0.0, 3.0); AliStack* stack = NULL; TParticle* part = NULL; TLorentzVector v[4]; TLorentzVector vSum; // Loop over events for (Int_t i = 0; i < rl->GetNumberOfEvents(); ++i) { rl->GetEvent(i); stack = rl->Stack(); Int_t nPrimary = 0; // Loop over all particles for (Int_t j = 0; j < stack->GetNtrack(); ++j) { part = stack->Particle(j); // Get particle part->Print(); // Print contents if (abs(part->GetPdgCode()) == 211 // Is pi+ or pi- & part->GetStatusCode() == 1 // Is stable final state & stack->IsPhysicalPrimary(j)) { // Is from generator level part->Momentum(v[nPrimary]); // Set content of v ++nPrimary; } } if (nPrimary != 4) { printf("Error: nPrimary=%d != 4 \n", nPrimary); continue; } // 4-vector sum vSum = v[0] + v[1] + v[2] + v[3]; // Fill 4pi histograms hM->Fill(vSum.M()); hPt->Fill(vSum.Perp()); // Fill pi+- histograms for (Int_t k = 0; k < 4; ++k) { hPt1->Fill(v[k].Perp()); } printf("\n"); } // Save plots as pdf hM->Draw(); c1->SaveAs("plotM.pdf"); hPt->Draw(); c1->SaveAs("plotPt.pdf"); hPt1->Draw(); c1->SaveAs("plotPt1.pdf"); }
void ExtractOutputHistos(Bool_t onlyPrims=0,Bool_t onlyPion=0,Int_t plotFlag=0) { // gROOT->SetStyle("Plain"); gStyle->SetPalette(1); const Int_t nbins=20; Double_t ptmin=0.06;//04; Double_t ptmax=2.0;//GeV Double_t logxmin = TMath::Log10(ptmin); Double_t logxmax = TMath::Log10(ptmax); Double_t binwidth = (logxmax-logxmin)/(nbins+1); enum {nb=nbins+1}; Double_t xbins[nb]; xbins[0] = ptmin; for (Int_t i=1;i<=nbins;i++) { xbins[i] = ptmin + TMath::Power(10,logxmin+(i)*binwidth); // cout<<xbins[i]<<endl; } // TH1F *h = new TH1F("h","hist with log x axis",nbins,xbins); TH1F *hMultCount = new TH1F("mult","averaged multiplicity (charg. prim)",80,-4.,4.); hMultCount->GetXaxis()->SetTitle("eta"); hMultCount->GetYaxis()->SetTitle("N/d#eta"); TH1F *hAllMC = new TH1F("allMC","All Tracks MC primaries",nbins,xbins); TH1F *hAllFound = new TH1F("allFound","All Tracks found",nbins,xbins); TH1F *hImperfect = new TH1F("imperfect","Imperfect tracks",nbins,xbins); TH1F *hPerfect = new TH1F("perfect","Perfect tracks",nbins,xbins); TH1F *hEff = new TH1F("efficiency","Efficiency (Perfect tracks in \"ALL MC\")",nbins,xbins); TH1F *hFake = new TH1F("fake","Fake tracks (Inperfect tracks in \"ALL MC\")",nbins,xbins); TH1F *hPurity = new TH1F("purity","Purity (Perfect tracks in \"All Found\")",nbins,xbins); TH1F *hAnna = new TH1F("annaEff","AnnalisaEff ",nbins,xbins); TH1F *hNoMCTrack = new TH1F("noMCtrack","noMCtrack ",nbins,xbins); TH1F *hEta = new TH1F("","",50,-2,2); // TH1F *hEtaMC = new TH1F("","",50,-2,2); TH2D *h2Ddca = new TH2D("dca2D","DCAvsPt2D",nbins,xbins,50,-0.05,0.05); TH2D *h2Dpt = new TH2D("dPt2D","dPtdvsPt2D",nbins,xbins,50,-25,25); // open run loader and load gAlice, kinematics and header AliRunLoader* runLoader = AliRunLoader::Open("galice.root"); if (!runLoader) { Error("Check kine", "getting run loader from file %s failed", "galice.root"); return; } runLoader->LoadgAlice(); gAlice = runLoader->GetAliRun(); if (!gAlice) { Error("Check kine", "no galice object found"); return; } runLoader->LoadHeader(); runLoader->LoadKinematics(); TFile* esdFile = TFile::Open("AliESDs.root"); if (!esdFile || !esdFile->IsOpen()) { Error("CheckESD", "opening ESD file %s failed", "AliESDs.root"); return; } AliESDEvent *esd = new AliESDEvent(); TTree* tree = (TTree*) esdFile->Get("esdTree"); if (!tree) { Error("CheckESD", "no ESD tree found"); return; } esd->ReadFromTree(tree); Int_t nTrackTotalMC = 0; Int_t nTrackFound = 0; Int_t nTrackImperfect = 0; Int_t nTrackPerfect = 0; Int_t nNoMCTrack = 0; for(Int_t iEv =0; iEv<tree->GetEntries(); iEv++){ tree->GetEvent(iEv); runLoader->GetEvent(iEv); printf("+++ event %i (of %lld) +++++++++++++++++++++++ # ESDtracks: %d \n",iEv,tree->GetEntries()-1,esd->GetNumberOfTracks()); Int_t nESDtracks = esd->GetNumberOfTracks(); for (Int_t iTrack = 0; iTrack < nESDtracks; iTrack++) { AliESDtrack* track = esd->GetTrack(iTrack); if (!(iTrack%1000)) printf("event %i: ESD track count %d (of %d)\n",iEv,iTrack,nESDtracks); Int_t label = track->GetLabel(); Int_t idx[12]; // Int_t ncl = track->GetITSclusters(idx); if(label<0) { // cout<< " ESD track label " << label; // cout<<" ---> imperfect track (label "<<label<<"<0) !! -> track Pt: "<< track->Pt() << endl; } AliStack* stack = runLoader->Stack(); // nTrackTotalMC += stack->GetNprimary(); TParticle* particle = stack->Particle(TMath::Abs(label)); Double_t pt = track->Pt(); if(particle) { if (TMath::Abs(particle->Eta())>etaCut) continue; Double_t ptMC = particle->Pt(); // Efficiencies if (onlyPion && TMath::Abs(particle->GetPdgCode())!=211) continue; if ( (!onlyPrims) || stack->IsPhysicalPrimary(TMath::Abs(label))) { // cout<<" # clusters "<<ncl<<endl; nTrackFound++; hAllFound->Fill(ptMC); hEta->Fill(track->Eta()); if (label<0) { nTrackImperfect++; hImperfect->Fill(ptMC); } else { nTrackPerfect++; hPerfect->Fill(ptMC); } } // following only for "true tracks, pions if(particle->Pt() < 0.001)continue; if (TMath::Abs(particle->GetPdgCode())!=211) continue; if (label>0) { // Impact parameters for Pions only Double_t dca = track->GetD(0,0,0.5); h2Ddca->Fill(ptMC,dca); // Pt resolution for Pions only Double_t dPt = (pt-ptMC)/ptMC*100; h2Dpt->Fill(ptMC,dPt); } } else { nNoMCTrackFound++; hNoMCTrack->Fill(pt); cout<<" according MC particle not found"<<endl; } } //entries track esd }//entries tree runLoader->UnloadHeader(); runLoader->UnloadKinematics(); delete runLoader; // Count trackable MC tracks CountTrackableMCs(hAllMC, onlyPrims, onlyPion); // Count trackable MC tracks CountPrimaries(hMultCount); // Get Errors right hMultCount->Sumw2(); hAllMC->Sumw2(); hAllFound->Sumw2(); hPerfect->Sumw2(); hImperfect->Sumw2(); h2Dpt->Sumw2(); h2Ddca->Sumw2(); // -- Global efficienies nTrackTotalMC = hAllMC->GetEntries(); Double_t eff = ((Double_t)nTrackPerfect)/nTrackTotalMC; printf("-> Total number of events: %lld -> MCtracks %d -> nPerfect %d -> Eff: %3.2lf \n", tree->GetEntries(),nTrackTotalMC,nTrackPerfect,eff); Double_t purity = ((Double_t)nTrackPerfect)/nTrackFound; printf("-> Total number of events: %lld -> FoundTracks %d -> nPerfect %d -> Purity: %3.2lf \n", tree->GetEntries(),nTrackFound,nTrackPerfect,purity); // Efficiencies - and normalize to 100% TF1 f1("f1","100+x*0",0.,1.e3); hPurity->Divide(hPerfect,hAllFound,1,1,"b"); hPurity->Multiply(&f1); hPurity->SetMarkerColor(kGreen); hPurity->SetMarkerStyle(21); hPurity->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); hPurity->SetStats(0); hPurity->GetYaxis()->SetRangeUser(0,100); hPurity->SetTitle("Efficiency & Purity"); hEff->Divide(hPerfect,hAllMC,1,1,"b"); hEff->Multiply(&f1); hEff->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); hEff->SetMarkerColor(kBlue); hEff->SetMarkerStyle(21); hEff->SetStats(0); hFake->Divide(hImperfect,hAllMC,1,1,"b"); hFake->Multiply(&f1); hFake->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); hFake->SetMarkerColor(kRed); hFake->SetMarkerStyle(21); hFake->SetStats(0); hAnna->Divide(hAllFound,hAllMC,1,1,"b"); hAnna->Multiply(&f1); hAnna->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); hAnna->SetMarkerColor(kBlack); hAnna->SetMarkerStyle(21); hAnna->SetStats(0); TCanvas *c1 = new TCanvas("c1","NoMCTrackFound");//,200,10,900,900); TVirtualPad *pad = c1->cd(); pad->SetGridx(); pad->SetGridy(); hNoMCTrack->Draw(); TCanvas *c2 = new TCanvas("c2","Eff&Purity");//,200,10,900,900); TVirtualPad *pad = c2->cd(); pad->SetGridx(); pad->SetGridy(); // pad->SetLogx(); hPurity->Draw("E"); hEff->Draw("Same E"); hFake->Draw("Same E"); hAnna->Draw("Same E"); TLegend *leg = new TLegend(0.1,0.8,0.6,0.9);leg->SetFillColor(0); leg->AddEntry(hPurity,"Purity (\"Perfect tracks\" within \"Found Tracks\")","PE"); leg->AddEntry(hEff,"Efficiency (\"Perfect tracks\" within \"MC findable Tracks\")","PE"); leg->AddEntry(hFake,"Fake (\"Inperfect tracks\" within \"MC findable Tracks\")","PE"); leg->AddEntry(hAnna,"AnnaLisa - Efficiency (\"Found tracks\" within \"MC findable Tracks\")","PE"); leg->Draw(); if (plotFlag==1){ hAllMC->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); hAllMC->Draw(); // MC pt distribution hAllFound->SetLineColor(2); hAllFound->Draw("same"); // MC pt distribution } /* .L ~/ITSupgrade/BuildDetector/DetectorK.cxx+ // All NEW DetectorK its("ALICE","ITS"); its.MakeAliceAllNew(0); its.SetMaxRadiusOfSlowDetectors(0.01); its.SolveViaBilloir(0); TGraph *c = its.GetGraphRecoEfficiency(0,3,2); c->Draw("C"); // Current DetectorK its("ALICE","ITS"); its.MakeAliceCurrent(0,0); its.SetMaxRadiusOfSlowDetectors(0.01); its.SolveViaBilloir(0); TGraph *c = its.GetGraphRecoEfficiency(0,4,2); c->Draw("C"); */ TCanvas *c3 = new TCanvas("c3","impact");//,200,10,900,900); c3->Divide(2,1); c3->cd(1); // Impact parameter // Impact parameter resolution --------------- h2Ddca->Draw("colz"); h2Ddca->FitSlicesY() ; TH2D *dcaM = (TH2D*)gDirectory->Get("dca2D_1"); dcaM->Draw("same"); TH2D *dcaRMS = (TH2D*)gDirectory->Get("dca2D_2"); //dcaRMS->Draw(); TGraphErrors *d0 = new TGraphErrors(); for (Int_t ibin =1; ibin<=dcaRMS->GetXaxis()->GetNbins(); ibin++) { d0->SetPoint( ibin-1,dcaRMS->GetBinCenter(ibin),dcaRMS->GetBinContent(ibin)*1e4); // microns d0->SetPointError(ibin-1,0,dcaRMS->GetBinError(ibin)*1e4); // microns } d0->SetMarkerStyle(21); d0->SetMaximum(200); d0->SetMinimum(0); d0->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); d0->GetYaxis()->SetTitle("R-#phi Pointing Resolution (#mum)"); d0->SetName("dca"); d0->SetTitle("DCAvsPt"); c3->cd(1); h2Ddca->Draw("surf2"); c3->cd(2); d0->Draw("APE"); // PT RESOLUTION ------------ TCanvas *c4 = new TCanvas("c4","pt resolution");//,200,10,900,900); c4->Divide(2,1); c4->cd(1); // Impact parameter h2Dpt->Draw("colz"); h2Dpt->FitSlicesY() ; TH2D *dPtM = (TH2D*)gDirectory->Get("dPt2D_1"); dPtM->Draw("same"); TH2D *dPtRMS = (TH2D*)gDirectory->Get("dPt2D_2"); // dPtRMS->Draw(""); TGraphErrors *gPt = new TGraphErrors(); for (Int_t ibin =1; ibin<=dPtRMS->GetXaxis()->GetNbins(); ibin++) { gPt->SetPoint( ibin-1,dPtRMS->GetBinCenter(ibin),dPtRMS->GetBinContent(ibin)); gPt->SetPointError(ibin-1,0,dPtRMS->GetBinError(ibin)); } gPt->SetMarkerStyle(21); gPt->SetMaximum(20); gPt->SetMinimum(0); gPt->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)"); gPt->GetYaxis()->SetTitle("relative momentum resolution (%)"); gPt->SetName("dPt"); gPt->SetTitle("DPTvsPt"); c4->cd(1); h2Dpt->Draw("surf2"); c4->cd(2); gPt->Draw("APE"); // EXPORT -------- TFile f("histos.root","RECREATE"); hMultCount->Write(); hAllMC->Write(); hAllFound->Write(); hImperfect->Write(); hPerfect->Write(); hNoMCTrack->Write(); hPurity->Write(); hEff->Write(); hFake->Write(); hAnna->Write(); h2Ddca->Write(); d0->Write(); h2Dpt->Write(); gPt->Write(); f.Close(); return; }
void CountTrackableMCs(TH1F *hAllMC, Bool_t onlyPrims,Bool_t onlyPion) { gSystem->Load("libITSUpgradeBase"); gSystem->Load("libITSUpgradeSim"); // open run loader and load gAlice, kinematics and header AliRunLoader* runLoader = AliRunLoader::Open("galice.root"); if (!runLoader) { Error("Check kine", "getting run loader from file %s failed", "galice.root"); return; } runLoader->LoadHeader(); runLoader->LoadKinematics(); runLoader->LoadTrackRefs(); AliLoader *dl = runLoader->GetDetectorLoader("ITS"); //Trackf TTree *trackRefTree = 0x0; TClonesArray *trackRef = new TClonesArray("AliTrackReference",1000); // TH1F *hRef = new TH1F("","",100,0,100); TH1F *hR = new TH1F("","",100,0,100); if (hAllMC==0) hAllMC = new TH1F("","",100,0.1,2); Float_t ptmin = hAllMC->GetBinCenter(1)-hAllMC->GetBinWidth(1)/2; Float_t ptmax = hAllMC->GetBinCenter(hAllMC->GetNbinsX())+hAllMC->GetBinWidth(hAllMC->GetNbinsX())/2; // Int_t nAllMC = 0; // Detector geometry TArrayD rmin(0); TArrayD rmax(0); GetDetectorRadii(&rmin,&rmax); TArrayI nLaySigs(rmin.GetSize()); printf("Counting trackable MC tracks ...\n"); for(Int_t iEv =0; iEv<runLoader->GetNumberOfEvents(); iEv++){ Int_t nTrackableTracks = 0; runLoader->GetEvent(iEv); AliStack* stack = runLoader->Stack(); printf("+++ event %i (of %d) +++++++++++++++++++++++ # total MCtracks: %d \n",iEv,runLoader->GetNumberOfEvents()-1,stack->GetNtrack()); trackRefTree=runLoader->TreeTR(); TBranch *br = trackRefTree->GetBranch("TrackReferences"); if(!br) { printf("no TR branch available , exiting \n"); return; } br->SetAddress(&trackRef); // init the trackRef tree trackRefTree=runLoader->TreeTR(); trackRefTree->SetBranchAddress("TrackReferences",&trackRef); // Count trackable MC tracks for (Int_t iMC=0; iMC<stack->GetNtrack(); iMC++) { TParticle* particle = stack->Particle(iMC); if (TMath::Abs(particle->Eta())>etaCut) continue; if (onlyPrims && !stack->IsPhysicalPrimary(iMC)) continue; if (onlyPion && TMath::Abs(particle->GetPdgCode())!=211) continue; Bool_t isTrackable = 0; nLaySigs.Reset(0); trackRefTree->GetEntry(stack->TreeKEntry(iMC)); Int_t nref=trackRef->GetEntriesFast(); for(Int_t iref =0; iref<nref; iref++){ AliTrackReference *trR = (AliTrackReference*)trackRef->At(iref); if(!trR) continue; if(trR->DetectorId()!=AliTrackReference::kITS) continue; Float_t radPos = trR->R(); hR->Fill(radPos); for (Int_t il=0; il<rmin.GetSize();il++) { if (radPos>=rmin.At(il)-0.1 && radPos<=rmax.At(il)+0.1) { // cout<<" in Layer "<<il<<" "<<radPos; nLaySigs.AddAt(1.,il); // cout<<" "<<nLaySigs.At(il)<<endl; } } } if (nLaySigs.GetSum()>=3) { isTrackable =1; // cout<<nLaySigs.GetSum()<<endl; } if (isTrackable) { Double_t ptMC = particle->Pt(); // Double_t etaMC = particle->Eta(); // if (ptMC>ptmin&&ptMC<ptmax) {nTrackableTracks++;hAllMC->Fill(ptMC);} if (ptMC>ptmin) {nTrackableTracks++;hAllMC->Fill(ptMC);} } } // entries tracks MC printf(" -> trackable MC tracks: %d (%d)\n",nTrackableTracks,hAllMC->GetEntries()); }//entries Events hR->DrawCopy(); hAllMC->DrawCopy(); runLoader->UnloadHeader(); runLoader->UnloadKinematics(); delete runLoader; }
void compClusHitsMod2(int nev=-1) { const int kSplit=0x1<<22; const int kSplCheck=0x1<<23; // gSystem->Load("libITSUpgradeBase"); gSystem->Load("libITSUpgradeSim"); gSystem->Load("libITSUpgradeRec"); gROOT->SetStyle("Plain"); AliCDBManager* man = AliCDBManager::Instance(); man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); man->SetSpecificStorage("GRP/GRP/Data", Form("local://%s",gSystem->pwd())); man->SetSpecificStorage("ITS/Align/Data", Form("local://%s",gSystem->pwd())); man->SetSpecificStorage("ITS/Calib/RecoParam", Form("local://%s",gSystem->pwd())); man->SetRun(0); TH1F* hL0A = new TH1F("hL0A", "Layer 0, polar angle", 20, 0, TMath::PiOver2()); hL0A->SetDirectory(0); hL0A->GetXaxis()->SetTitle("#alpha"); TH1F* hL0B = new TH1F("hL0B", "Layer 0, azimuthal angle", 20, 0, TMath::PiOver2()); hL0B->SetDirectory(0); hL0B->GetXaxis()->SetTitle("#beta"); TH1F* hL1A = new TH1F("hL1A", "Layer 1, polar angle", 20, 0, TMath::PiOver2()); hL1A->SetDirectory(0); hL1A->GetXaxis()->SetTitle("#alpha"); TH1F* hL1B = new TH1F("hL1B", "Layer 1, azimuthal angle", 20, 0, TMath::PiOver2()); hL1B->SetDirectory(0); hL1B->GetXaxis()->SetTitle("#beta"); TH1F* hL2A = new TH1F("hL2A", "Layer 2, polar angle", 20, 0, TMath::PiOver2()); hL2A->SetDirectory(0); hL2A->GetXaxis()->SetTitle("#alpha"); TH1F* hL2B = new TH1F("hL2B", "Layer 2, azimuthal angle", 20, 0, TMath::PiOver2()); hL2B->SetDirectory(0); hL2B->GetXaxis()->SetTitle("#beta"); TH1F* hL3A = new TH1F("hL3A", "Layer 3, polar angle", 20, 0, TMath::PiOver2()); hL3A->SetDirectory(0); hL3A->GetXaxis()->SetTitle("#alpha"); TH1F* hL3B = new TH1F("hL3B", "Layer 3, azimuthal angle", 20, 0, TMath::PiOver2()); hL3B->SetDirectory(0); hL3B->GetXaxis()->SetTitle("#beta"); TH1F* hL4A = new TH1F("hL4A", "Layer 4, polar angle", 20, 0, TMath::PiOver2()); hL4A->SetDirectory(0); hL4A->GetXaxis()->SetTitle("#alpha"); TH1F* hL4B = new TH1F("hL4B", "Layer 4, azimuthal angle", 20, 0, TMath::PiOver2()); hL4B->SetDirectory(0); hL4B->GetXaxis()->SetTitle("#beta"); TH1F* hL5A = new TH1F("hL5A", "Layer 5, polar angle", 20, 0, TMath::PiOver2()); hL5A->SetDirectory(0); hL5A->GetXaxis()->SetTitle("#alpha"); TH1F* hL5B = new TH1F("hL5B", "Layer 5, azimuthal angle", 20, 0, TMath::PiOver2()); hL5B->SetDirectory(0); hL5B->GetXaxis()->SetTitle("#beta"); TH1F* hL6A = new TH1F("hL6A", "Layer 6, polar angle", 20, 0, TMath::PiOver2()); hL6A->SetDirectory(0); hL6A->GetXaxis()->SetTitle("#alpha"); TH1F* hL6B = new TH1F("hL6B", "Layer 6, azimuthal angle", 20, 0, TMath::PiOver2()); hL6B->SetDirectory(0); hL6B->GetXaxis()->SetTitle("#beta"); gAlice=NULL; AliRunLoader* runLoader = AliRunLoader::Open("galice.root"); runLoader->LoadgAlice(); gAlice = runLoader->GetAliRun(); runLoader->LoadHeader(); runLoader->LoadKinematics(); runLoader->LoadRecPoints(); runLoader->LoadSDigits(); runLoader->LoadHits(); AliLoader *dl = runLoader->GetDetectorLoader("ITS"); AliGeomManager::LoadGeometry("geometry.root"); TObjArray algITS; AliGeomManager::LoadAlignObjsFromCDBSingleDet("ITS",algITS); AliGeomManager::ApplyAlignObjsToGeom(algITS); // AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE); AliITSMFTClusterPix::SetGeom(gm); // AliITSURecoDet *its = new AliITSURecoDet(gm, "ITSinterface"); its->CreateClusterArrays(); // Double_t xg1,yg1,zg1=0.,xg0,yg0,zg0=0.,tg0; Double_t xExit,yExit,zExit,xEnt,yEnt,zEnt,tof1; // TTree *cluTree = 0x0; TTree *hitTree = 0x0; TClonesArray *hitList=new TClonesArray("AliITSMFTHit"); // Float_t xyzClGloF[3]; Double_t xyzClGlo[3],xyzClTr[3]; Int_t labels[3]; int nLab = 0; int nlr=its->GetNLayersActive(); int ntotev = (Int_t)runLoader->GetNumberOfEvents(); printf("N Events : %i \n",ntotev); if (nev>0) ntotev = TMath::Min(nev,ntotev); // // output tree TFile* flOut = TFile::Open("clInfo.root","recreate"); TTree* trOut = new TTree("clitsu","clitsu"); clSumm cSum; trOut->Branch("evID", &cSum.evID ,"evID/I"); trOut->Branch("volID",&cSum.volID,"volID/I"); trOut->Branch("lrID", &cSum.lrID ,"lrID/I"); trOut->Branch("clID", &cSum.clID ,"clID/I"); trOut->Branch("nPix", &cSum.nPix ,"nPix/I"); trOut->Branch("nX" , &cSum.nX ,"nX/I"); trOut->Branch("nZ" , &cSum.nZ ,"nZ/I"); trOut->Branch("q" , &cSum.q ,"q/I"); trOut->Branch("pt" , &cSum.pt ,"pt/F"); trOut->Branch("eta" ,&cSum.eta ,"eta/F"); trOut->Branch("phi" , &cSum.phi ,"phi/F"); trOut->Branch("xyz", cSum.xyz, "xyz[3]/F"); trOut->Branch("dX" , &cSum.dX ,"dX/F"); trOut->Branch("dY" , &cSum.dY ,"dY/F"); trOut->Branch("dZ" , &cSum.dZ ,"dZ/F"); trOut->Branch("split",&cSum.split,"split/O"); trOut->Branch("prim", &cSum.prim, "prim/O"); trOut->Branch("pdg", &cSum.pdg, "pdg/I"); trOut->Branch("ntr", &cSum.ntr, "ntr/I"); trOut->Branch("alpha", &cSum.alpha, "alpha/F"); trOut->Branch("beta", &cSum.beta, "beta/F"); trOut->Branch("nRowPatt", &cSum.nRowPatt, "nRowPatt/I"); trOut->Branch("nColPatt", &cSum.nColPatt, "nColPatt/I"); TopDatabase DB; for (Int_t iEvent = 0; iEvent < ntotev; iEvent++) { printf("\n Event %i \n",iEvent); runLoader->GetEvent(iEvent); AliStack *stack = runLoader->Stack(); cluTree=dl->TreeR(); hitTree=dl->TreeH(); hitTree->SetBranchAddress("ITS",&hitList); // // read clusters for (int ilr=nlr;ilr--;) { TBranch* br = cluTree->GetBranch(Form("ITSRecPoints%d",ilr)); if (!br) {printf("Did not find cluster branch for lr %d\n",ilr); exit(1);} br->SetAddress(its->GetLayerActive(ilr)->GetClustersAddress()); } cluTree->GetEntry(0); its->ProcessClusters(); // // read hits for(Int_t iEnt=0;iEnt<hitTree->GetEntries();iEnt++){//entries loop of the hits hitTree->GetEntry(iEnt); int nh = hitList->GetEntries(); for(Int_t iHit=0; iHit<nh;iHit++){ AliITSMFTHit *pHit = (AliITSMFTHit*)hitList->At(iHit); int mcID = pHit->GetTrack(); //printf("MCid: %d %d %d Ch %d\n",iEnt,iHit, mcID, pHit->GetChip()); TClonesArray* harr = arrMCTracks.GetEntriesFast()>mcID ? (TClonesArray*)arrMCTracks.At(mcID) : 0; if (!harr) { harr = new TClonesArray("AliITSMFTHit"); // 1st encounter of the MC track arrMCTracks.AddAtAndExpand(harr,mcID); } // new ( (*harr)[harr->GetEntriesFast()] ) AliITSMFTHit(*pHit); } } // return; // // compare clusters and hits // printf(" tree entries: %lld\n",cluTree->GetEntries()); // for (int ilr=0;ilr<nlr;ilr++) { AliITSURecoLayer* lr = its->GetLayerActive(ilr); TClonesArray* clr = lr->GetClusters(); int nClu = clr->GetEntries(); //printf("Layer %d : %d clusters\n",ilr,nClu); // for (int icl=0;icl<nClu;icl++) { AliITSMFTClusterPix *cl = (AliITSMFTClusterPix*)clr->At(icl); int modID = cl->GetVolumeId(); //------------ check if this is a split cluster int sInL = modID - gm->GetFirstChipIndex(ilr); if (!cl->TestBit(kSplCheck)) { cl->SetBit(kSplCheck); // check if there is no other cluster with same label on this module AliITSURecoSens* sens = lr->GetSensor(sInL); int nclSn = sens->GetNClusters(); int offs = sens->GetFirstClusterId(); // printf("To check for %d (mod:%d) N=%d from %d\n",icl,modID,nclSn,offs); for (int ics=0;ics<nclSn;ics++) { AliITSMFTClusterPix* clusT = (AliITSMFTClusterPix*)lr->GetCluster(offs+ics); // access to clusters if (clusT==cl) continue; for (int ilb0=0;ilb0<3;ilb0++) { int lb0 = cl->GetLabel(ilb0); if (lb0<=-1) break; for (int ilb1=0;ilb1<3;ilb1++) { int lb1 = clusT->GetLabel(ilb1); if (lb1<=-1) break; if (lb1==lb0) { cl->SetBit(kSplit); clusT->SetBit(kSplit); /* printf("Discard clusters of module %d:\n",modID); cl->Print(); clusT->Print(); */ break; } } } } } //------------ const AliITSMFTSegmentationPix* segm = gm->GetSegmentation(ilr); // cl->GetGlobalXYZ(xyzClGloF); int clsize = cl->GetNPix(); for (int i=3;i--;) xyzClGlo[i] = xyzClGloF[i]; const TGeoHMatrix* mat = gm->GetMatrixSens(modID); if (!mat) {printf("failed to get matrix for module %d\n",cl->GetVolumeId());} mat->MasterToLocal(xyzClGlo,xyzClTr); // int col,row; segm->LocalToDet(xyzClTr[0],xyzClTr[2],row,col); // effective col/row nLab = 0; for (int il=0;il<3;il++) { if (cl->GetLabel(il)>=0) labels[nLab++] = cl->GetLabel(il); else break; } // find hit info for (int il=0;il<nLab;il++) { TClonesArray* htArr = (TClonesArray*)arrMCTracks.At(labels[il]); //printf("check %d/%d LB %d %p\n",il,nLab,labels[il],htArr); if (!htArr) {printf("did not find MChits for label %d ",labels[il]); cl->Print(); continue;} // int nh = htArr->GetEntriesFast(); AliITSMFTHit *pHit=0; for (int ih=nh;ih--;) { AliITSMFTHit* tHit = (AliITSMFTHit*)htArr->At(ih); if (tHit->GetChip()!=modID) continue; pHit = tHit; break; } if (!pHit) { printf("did not find MChit for label %d on module %d ",il,modID); cl->Print(); htArr->Print(); continue; } // pHit->GetPositionG(xg1,yg1,zg1); pHit->GetPositionG0(xg0,yg0,zg0,tg0); // double txyzH[3],gxyzH[3] = { (xg1+xg0)/2, (yg1+yg0)/2, (zg1+zg0)/2 }; mat->MasterToLocal(gxyzH,txyzH); double rcl = TMath::Sqrt(xyzClTr[0]*xyzClTr[0]+xyzClTr[1]*xyzClTr[1]); double rht = TMath::Sqrt(txyzH[0]*txyzH[0]+txyzH[1]*txyzH[1]); // //Angles determination pHit->GetPositionL(xExit,yExit,zExit,gm); pHit->GetPositionL0(xEnt,yEnt,zEnt,tof1,gm); Double_t dirHit[3]={(xExit-xEnt),(yExit-yEnt),(zExit-zEnt)}; /*double PG[3] = {(double)pHit->GetPXG(), (double)pHit->GetPYG(), (double)pHit->GetPZG()}; //Momentum at hit-point in Global Frame double PL[3]; if (TMath::Abs(PG[0])<10e-7 && TMath::Abs(PG[1])<10e-7) { pHit->Dump(); int lb = pHit->GetTrack(); stack->Particle(lb)->Print(); continue; } mat->MasterToLocalVect(PG,PL); //Momentum in local Frame //printf(">> %e %e %e %e %e %e\n",PG[0],PL[0],PG[1],PL[1],PG[2],PL[2]);*/ Double_t alpha1 = TMath::ACos(TMath::Abs(dirHit[1])/TMath::Sqrt(dirHit[0]*dirHit[0]+dirHit[1]*dirHit[1]+dirHit[2]*dirHit[2])); //Polar Angle Float_t alpha2 = (Float_t) alpha1; //convert to float cSum.alpha = alpha2; Double_t beta1; beta1 = TMath::ATan2(dirHit[0],dirHit[2]); //Azimuthal angle, values from -Pi to Pi Float_t beta2 = (Float_t) beta1; cSum.beta = beta2; if(ilr==0){ hL0A->Fill(alpha2); hL0B->Fill(beta2); } if(ilr==1){ hL1A->Fill(alpha2); hL1B->Fill(beta2); } if(ilr==2){ hL2A->Fill(alpha2); hL2B->Fill(beta2); } if(ilr==3){ hL3A->Fill(alpha2); hL3B->Fill(beta2); } if(ilr==4){ hL4A->Fill(alpha2); hL4B->Fill(beta2); } if(ilr==5){ hL5A->Fill(alpha2); hL5B->Fill(beta2); } if(ilr==6){ hL6A->Fill(alpha2); hL6B->Fill(beta2); } GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4); if (cl->TestBit(kSplit)) { if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4); GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize); } if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4); GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize); // cSum.evID = iEvent; cSum.volID = cl->GetVolumeId(); cSum.lrID = ilr; cSum.clID = icl; cSum.nPix = cl->GetNPix(); cSum.nX = cl->GetNx(); cSum.nZ = cl->GetNz(); cSum.q = cl->GetQ(); cSum.split = cl->TestBit(kSplit); cSum.dX = (txyzH[0]-xyzClTr[0])*1e4; cSum.dY = (txyzH[1]-xyzClTr[1])*1e4; cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4; cSum.nRowPatt = cl-> GetPatternRowSpan(); cSum.nColPatt = cl-> GetPatternColSpan(); DB.AccountTopology(*cl, cSum.dX, cSum.dZ, cSum.alpha, cSum.beta); GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4); if (cl->TestBit(kSplit)) { if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4); GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize); } if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4); GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4); GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize); // cSum.evID = iEvent; cSum.volID = cl->GetVolumeId(); cSum.lrID = ilr; cSum.clID = icl; cSum.nPix = cl->GetNPix(); cSum.nX = cl->GetNx(); cSum.nZ = cl->GetNz(); cSum.q = cl->GetQ(); cSum.split = cl->TestBit(kSplit); cSum.dX = (txyzH[0]-xyzClTr[0])*1e4; cSum.dY = (txyzH[1]-xyzClTr[1])*1e4; cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4; cSum.nRowPatt = cl-> GetPatternRowSpan(); cSum.nColPatt = cl-> GetPatternColSpan(); int label = cl->GetLabel(0); TParticle* part = 0; if (label>=0 && (part=stack->Particle(label)) ) { cSum.pdg = part->GetPdgCode(); cSum.eta = part->Eta(); cSum.pt = part->Pt(); cSum.phi = part->Phi(); cSum.prim = stack->IsPhysicalPrimary(label); } cSum.ntr = 0; for (int ilb=0;ilb<3;ilb++) if (cl->GetLabel(ilb)>=0) cSum.ntr++; for (int i=0;i<3;i++) cSum.xyz[i] = xyzClGloF[i]; // trOut->Fill(); /* if (clsize==5) { printf("\nL%d(%c) Mod%d, Cl:%d | %+5.1f %+5.1f (%d/%d)|H:%e %e %e | C:%e %e %e\n",ilr,cl->TestBit(kSplit) ? 'S':'N', modID,icl,(txyzH[0]-xyzClTr[0])*1e4,(txyzH[2]-xyzClTr[2])*1e4, row,col, gxyzH[0],gxyzH[1],gxyzH[2],xyzClGlo[0],xyzClGlo[1],xyzClGlo[2]); cl->Print(); pHit->Print(); // double a0,b0,c0,a1,b1,c1,e0; pHit->GetPositionL0(a0,b0,c0,e0); pHit->GetPositionL(a1,b1,c1); float cloc[3]; cl->GetLocalXYZ(cloc); printf("LocH: %e %e %e | %e %e %e\n",a0,b0,c0,a1,b1,c1); printf("LocC: %e %e %e | %e %e %e\n",cloc[0],cloc[1],cloc[2],xyzClTr[0],xyzClTr[1],xyzClTr[2]); } */ // } } } // layerClus.Clear(); // arrMCTracks.Delete(); }//event loop // DB.EndAndSort(); DB.SetThresholdCumulative(0.95); cout << "Over threshold: : "<< DB.GetOverThr()<<endl; DB.Grouping(10,10); DB.PrintDB("Database1.txt"); flOut->cd(); trOut->Write(); delete trOut; flOut->Close(); flOut->Delete(); DrawReport("clinfo.ps",&histoArr); TFile* flDB = TFile::Open("TopologyDatabase.root", "recreate"); flDB->WriteObject(&DB,"DB","kSingleKey"); flDB->Close(); delete flDB; TCanvas* cnv123 = new TCanvas("cnv123","cnv123"); cnv123->Divide(1,2); cnv123->Print("anglesdistr.pdf["); cnv123->cd(1); hL0A->Draw(); cnv123->cd(2); hL0B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL1A->Draw(); cnv123->cd(2); hL1B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL2A->Draw(); cnv123->cd(2); hL2B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL3A->Draw(); cnv123->cd(2); hL3B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL4A->Draw(); cnv123->cd(2); hL4B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL5A->Draw(); cnv123->cd(2); hL5B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->cd(1); hL6A->Draw(); cnv123->cd(2); hL6B->Draw(); cnv123->Print("anglesdistr.pdf"); cnv123->Print("anglesdistr.pdf]"); // }
/** * Event processing */ void UserExec(Option_t*) { // Get the input data - MC event AliMCEvent* mcEvent = MCEvent(); if (!mcEvent) { AliWarning("No MC event found"); return; } // Get the input data - ESD event AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent()); if (!esd) { AliWarning("No ESD event found for input event"); return; } if (fFirstEvent && esd->GetESDRun()) { fInspector.ReadRunDetails(esd); AliInfo(Form("Initializing with parameters from the ESD:\n" " AliESDEvent::GetBeamEnergy() ->%f\n" " AliESDEvent::GetBeamType() ->%s\n" " AliESDEvent::GetCurrentL3() ->%f\n" " AliESDEvent::GetMagneticField()->%f\n" " AliESDEvent::GetRunNumber() ->%d\n", esd->GetBeamEnergy(), esd->GetBeamType(), esd->GetCurrentL3(), esd->GetMagneticField(), esd->GetRunNumber())); fFirstEvent = false; } // Get the particle stack AliStack* stack = mcEvent->Stack(); // Some variables UInt_t triggers; // Trigger bits Bool_t lowFlux; // Low flux flag UShort_t iVz; // Vertex bin from ESD Double_t vZ; // Z coordinate from ESD Double_t cent; // Centrality UShort_t iVzMc; // Vertex bin from MC Double_t vZMc; // Z coordinate of IP vertex from MC Double_t b; // Impact parameter Int_t nPart; // Number of participants Int_t nBin; // Number of binary collisions Double_t phiR; // Reaction plane from MC UShort_t nClusters;// Number of clisters // Process the data Int_t retESD = fInspector.Process(esd, triggers, lowFlux, iVz, vZ, cent, nClusters); Int_t retMC = fInspector.ProcessMC(mcEvent, triggers, iVzMc, vZMc, b, nPart, nBin, phiR); Bool_t hasESDVtx = retESD == AliFMDEventInspector::kOk; Bool_t hasMCVtx = retMC == AliFMDEventInspector::kOk; if (hasESDVtx) fVertexESD->Fill(vZ); if (hasMCVtx) fVertexMC->Fill(vZMc); Bool_t isMcInel = true; // (triggers & AliAODForwardMult::kB); Bool_t isMcNSD = (triggers & AliAODForwardMult::kMCNSD); Int_t mESD = 0; const AliMultiplicity* spdmult = esd->GetMultiplicity(); if (!spdmult) { AliWarning("No SPD multiplicity"); } else { // Check if we have one or more tracklets // in the range -1 < eta < 1 to set the INEL>0 // trigger flag. Int_t n = spdmult->GetNumberOfTracklets(); for (Int_t j = 0; j < n; j++) if(TMath::Abs(spdmult->GetEta(j)) < 1) mESD++; } // Reset cache fData->Reset(); Int_t mMC = 0; // Number of particles in |eta|<1 // Loop over all tracks Int_t nTracks = mcEvent->GetNumberOfTracks(); for (Int_t iTr = 0; iTr < nTracks; iTr++) { AliMCParticle* particle = static_cast<AliMCParticle*>(mcEvent->GetTrack(iTr)); // Check the returned particle if (!particle) continue; // Check if this charged and a primary Bool_t isCharged = particle->Charge() != 0; Bool_t isPrimary = stack->IsPhysicalPrimary(iTr); if (!isCharged || !isPrimary) continue; // Fill (eta,phi) of the particle into histograsm for b Double_t eta = particle->Eta(); Double_t phi = particle->Phi(); fData->Fill(eta, phi); if (TMath::Abs(eta) <= 1) mMC++; } Int_t m = mESD; if (fTrackletRequirement == kMC) m = mMC; fM->Fill(m); bool isMcInelGt0 = isMcInel && (mMC > 0); bool hasVertex = true; if (fVertexRequirement & kMC) hasVertex = hasVertex && hasMCVtx; if (fVertexRequirement & kESD) hasVertex = hasVertex && hasESDVtx; if (isMcInel) { fTriggers->Fill(0); bool triggered = (triggers & AliAODForwardMult::kInel); if (triggered) fTriggers->Fill(1); fInel.AddEvent(triggered, hasVertex, m, fData); } if (isMcInel) { // && nClusters > 0) { fTriggers->Fill(2); bool triggered = (triggers & AliAODForwardMult::kNClusterGt0); if (triggered) fTriggers->Fill(3); fNClusterGt0.AddEvent(triggered, hasVertex, m, fData); } if (isMcInelGt0) { fTriggers->Fill(4); bool triggered = (triggers & AliAODForwardMult::kInelGt0); if (triggered) fTriggers->Fill(5); fInelGt0.AddEvent(triggered, hasVertex, m, fData); } if (isMcNSD) { fTriggers->Fill(6); bool triggered = (triggers & AliAODForwardMult::kNSD); if (triggered) fTriggers->Fill(7); fNSD.AddEvent(triggered, hasVertex, m, fData); } PostData(1, fList); }
int main(int argc, char* argv[]) { TApplication theApp(srcName.Data(), &argc, argv); //============================================================================= for (int i=0; i<argc; i++) cout << i << ", " << argv[i] << endl; //============================================================================= if (argc<5) return -1; TString sPath = argv[1]; if (sPath.IsNull()) return -1; TString sFile = argv[2]; if (sFile.IsNull()) return -1; TString sJetR = argv[3]; if (sJetR.IsNull()) return -1; TString sSjeR = argv[4]; if (sSjeR.IsNull()) return -1; //============================================================================= sPath.ReplaceAll("#", "/"); //============================================================================= double dJetR = -1.; if (sJetR=="JetR02") dJetR = 0.2; if (sJetR=="JetR03") dJetR = 0.3; if (sJetR=="JetR04") dJetR = 0.4; if (sJetR=="JetR05") dJetR = 0.5; if (dJetR<0.) return -1; cout << "Jet R = " << dJetR << endl; //============================================================================= double dSjeR = -1.; if (sSjeR=="SjeR01") dSjeR = 0.1; if (sSjeR=="SjeR02") dSjeR = 0.2; if (sSjeR=="SjeR03") dSjeR = 0.3; if (sSjeR=="SjeR04") dSjeR = 0.4; if (dSjeR<0.) return -1; cout << "Sub-jet R = " << dSjeR << endl; //============================================================================= const double dJetsPtMin = 0.001; const double dCutEtaMax = 1.6; const double dJetEtaMax = 1.; const double dJetAreaRef = TMath::Pi() * dJetR * dJetR; fastjet::GhostedAreaSpec areaSpc(dCutEtaMax); fastjet::JetDefinition jetsDef(fastjet::antikt_algorithm, dJetR, fastjet::BIpt_scheme, fastjet::Best); //fastjet::AreaDefinition areaDef(fastjet::active_area,areaSpc); fastjet::AreaDefinition areaDef(fastjet::active_area_explicit_ghosts,areaSpc); //fastjet::JetDefinition bkgsDef(fastjet::kt_algorithm, 0.2, fastjet::BIpt_scheme, fastjet::Best); //fastjet::AreaDefinition aBkgDef(fastjet::active_area_explicit_ghosts, areaSpc); fastjet::Selector selectJet = fastjet::SelectorAbsEtaMax(dJetEtaMax); //fastjet::Selector selectRho = fastjet::SelectorAbsEtaMax(dCutEtaMax-0.2); //fastjet::Selector selecHard = fastjet::SelectorNHardest(2); //fastjet::Selector selectBkg = selectRho * (!(selecHard)); //fastjet::JetMedianBackgroundEstimator bkgsEstimator(selectBkg, bkgsDef, aBkgDef); //fastjet::Subtractor bkgSubtractor(&bkgsEstimator); fastjet::JetDefinition subjDef(fastjet::antikt_algorithm, dSjeR, fastjet::BIpt_scheme, fastjet::Best); //============================================================================= std::vector<fastjet::PseudoJet> fjInput; //============================================================================= TList *list = new TList(); TH1D *hPtHat = new TH1D("hPtHat", "", 1000, 0., 1000.); TH1D *hJet = new TH1D("hJet", "", 1000, 0., 1000.); hJet->Sumw2(); list->Add(hJet); TH2D *hJetNsj = new TH2D("hJetNsj", "", 1000, 0., 1000., 101, -0.5, 100.5); hJetNsj->Sumw2(); list->Add(hJetNsj); TH2D *hJetIsj = new TH2D("hJetIsj", "", 1000, 0., 1000., 1000, 0., 1000.); hJetIsj->Sumw2(); list->Add(hJetIsj); TH2D *hJet1sj = new TH2D("hJet1sj", "", 1000, 0., 1000., 1000, 0., 1000.); hJet1sj->Sumw2(); list->Add(hJet1sj); TH2D *hJet2sj = new TH2D("hJet2sj", "", 1000, 0., 1000., 1000, 0., 1000.); hJet2sj->Sumw2(); list->Add(hJet2sj); TH2D *hJetDsj = new TH2D("hJetDsj", "", 1000, 0., 1000., 1000, 0., 1000.); hJetDsj->Sumw2(); list->Add(hJetDsj); TH2D *hJetIsz = new TH2D("hJetIsz", "", 1000, 0., 1000., 120, 0., 1.2); hJetIsz->Sumw2(); list->Add(hJetIsz); TH2D *hJet1sz = new TH2D("hJet1sz", "", 1000, 0., 1000., 120, 0., 1.2); hJet1sz->Sumw2(); list->Add(hJet1sz); TH2D *hJet2sz = new TH2D("hJet2sz", "", 1000, 0., 1000., 120, 0., 1.2); hJet2sz->Sumw2(); list->Add(hJet2sz); TH2D *hJetDsz = new TH2D("hJetDsz", "", 1000, 0., 1000., 120, 0., 1.2); hJetDsz->Sumw2(); list->Add(hJetDsz); //============================================================================= AliRunLoader *rl = AliRunLoader::Open(Form("%s/galice.root",sPath.Data())); if (!rl) return -1; if (rl->LoadHeader()) return -1; if (rl->LoadKinematics("READ")) return -1; //============================================================================= for (Int_t iEvent=0; iEvent<rl->GetNumberOfEvents(); iEvent++) { fjInput.resize(0); if (rl->GetEvent(iEvent)) continue; //============================================================================= AliStack *pStack = rl->Stack(); if (!pStack) continue; AliHeader *pHeader = rl->GetHeader(); if (!pHeader) continue; //============================================================================= AliGenPythiaEventHeader *pHeadPy = (AliGenPythiaEventHeader*)pHeader->GenEventHeader(); if (!pHeadPy) continue; hPtHat->Fill(pHeadPy->GetPtHard()); //============================================================================= for (Int_t i=0; i<pStack->GetNtrack(); i++) if (pStack->IsPhysicalPrimary(i)) { TParticle *pTrk = pStack->Particle(i); if (!pTrk) continue; if (TMath::Abs(pTrk->Eta())>dCutEtaMax) { pTrk = 0; continue; } // TParticlePDG *pPDG = pTrk->GetPDG(); if (!pPDG) { pTrk = 0; continue; } fjInput.push_back(fastjet::PseudoJet(pTrk->Px(), pTrk->Py(), pTrk->Pz(), pTrk->P())); // pPDG = 0; pTrk = 0; } //============================================================================= fastjet::ClusterSequenceArea clustSeq(fjInput, jetsDef, areaDef); std::vector<fastjet::PseudoJet> includJets = clustSeq.inclusive_jets(dJetsPtMin); // std::vector<fastjet::PseudoJet> subtedJets = bkgSubtractor(includJets); std::vector<fastjet::PseudoJet> selectJets = selectJet(includJets); // std::vector<fastjet::PseudoJet> sortedJets = fastjet::sorted_by_pt(selectJets); for (int j=0; j<selectJets.size(); j++) { double dJet = selectJets[j].pt(); hJet->Fill(dJet); //============================================================================= fastjet::Filter trimmer(subjDef, fastjet::SelectorPtFractionMin(0.)); fastjet::PseudoJet trimmdJet = trimmer(selectJets[j]); std::vector<fastjet::PseudoJet> trimmdSj = trimmdJet.pieces(); double nIsj = 0.; double d1sj = -1.; int k1sj = -1; double d2sj = -1.; int k2sj = -1; for (int i=0; i<trimmdSj.size(); i++) { double dIsj = trimmdSj[i].pt(); if (dIsj<0.001) continue; hJetIsj->Fill(dJet, dIsj); hJetIsz->Fill(dJet, dIsj/dJet); if (dIsj>d1sj) { d2sj = d1sj; k2sj = k1sj; d1sj = dIsj; k1sj = i; } else if (dIsj>d2sj) { d2sj = dIsj; k2sj = i; } nIsj += 1.; } hJetNsj->Fill(dJet, nIsj); if (d1sj>0.) { hJet1sj->Fill(dJet, d1sj); hJet1sz->Fill(dJet, d1sj/dJet); } if (d2sj>0.) { hJet2sj->Fill(dJet, d2sj); hJet2sz->Fill(dJet, d2sj/dJet); } if ((d1sj>0.) && (d2sj>0.)) { double dsj = d1sj - d2sj; double dsz = dsj / dJet; hJetDsj->Fill(dJet, dsj); hJetDsz->Fill(dJet, dsz); } } //============================================================================= pStack = 0; pHeadPy = 0; pHeader = 0; } //============================================================================= rl->UnloadgAlice(); rl->UnloadHeader(); rl->UnloadKinematics(); rl->RemoveEventFolder(); //============================================================================= TFile *file = TFile::Open(Form("%s/pyxsec_hists.root",sPath.Data()), "READ"); TList *lXsc = (TList*)file->Get("cFilterList"); file->Close(); TH1D *hWeightSum = (TH1D*)lXsc->FindObject("h1Trials"); hWeightSum->SetName("hWeightSum"); TProfile *hSigmaGen = (TProfile*)lXsc->FindObject("h1Xsec"); hSigmaGen->SetName("hSigmaGen"); //============================================================================= file = TFile::Open(Form("%s.root",sFile.Data()), "NEW"); hPtHat->Write(); hWeightSum->Write(); hSigmaGen->Write(); list->Write(); file->Close(); //============================================================================= cout << "DONE" << endl; //============================================================================= return 0; }