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; }
//_____________________________________________________________________________ Bool_t ProofPythia::Process(Long64_t entry) { // Main event loop fPythia->GenerateEvent(); if (entry < 2) fPythia->EventListing(); fPythia->ImportParticles(fP, "All"); Int_t nTot = fPythia->GetN(); fPythia->ImportParticles(fP, "All"); Int_t np = fP->GetEntriesFast(); // Particle loop Int_t nCharged = 0; for (Int_t ip = 0; ip < np; ip++) { TParticle* part = (TParticle*) fP->At(ip); Int_t ist = part->GetStatusCode(); Int_t pdg = part->GetPdgCode(); if (ist != 1) continue; Float_t charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); if (charge == 0.) continue; nCharged++; Float_t eta = part->Eta(); Float_t pt = part->Pt(); if (pt > 0.) fPt->Fill(pt); if ((eta > -10) && (eta < 10)) fEta->Fill(eta); } fHist->Fill(nCharged); fTot->Fill(nTot); return kTRUE; }
//_____________________________________________________________________________ Int_t amsvmc_MCStack::GetCurrentParentTrackNumber() const { /// \return The current track parent ID. TParticle* current = GetCurrentTrack(); if (current) return current->GetFirstMother(); else return -1; }
void kine_daughters(IlcEveTrack* parent, IlcStack* stack, Double_t min_pt, Double_t min_p, Bool_t pdg_col, Bool_t recurse) { TParticle *p = stack->Particle(parent->GetLabel()); if (p->GetNDaughters() > 0) { TEveTrackPropagator* rs = parent->GetPropagator(); for (int d=p->GetFirstDaughter(); d>0 && d<=p->GetLastDaughter(); ++d) { TParticle* dp = stack->Particle(d); if (dp->Pt() < min_pt && dp->P() < min_p) continue; IlcEveTrack* dtrack = new IlcEveTrack(dp, d, rs); char form[1000]; sprintf(form,"%s [%d]", dp->GetName(), d); dtrack->SetName(form); dtrack->SetStdTitle(); set_track_color(dtrack, pdg_col); gEve->AddElement(dtrack, parent); if (recurse) kine_daughters(dtrack, stack, min_pt, min_p, pdg_col, recurse); } } }
void testTDime(Int_t nev = 100) { gSystem->Load("libEVGEN"); gSystem->Load("libTDime"); gSystem->Load("libdime"); TDime* dime = new TDime(); dime->SetEnergyCMS(7000.0); dime->SetYRange(-2.0, 2.0); // Set rapidity range of mesons dime->SetMinPt(0.1); // Minimum pT of mesons dime->Initialize(); // (pi+pi-) histograms TH1* hM = new TH1D("hM", "DIME #pi^{+}#pi^{-};M_{#pi^{+}#pi^{-}} #[]{GeV/#it{c}^{2}}", 100, 0.0, 5.0); TClonesArray* particles = new TClonesArray("TParticle", 6); TParticle* part = NULL; TLorentzVector v[2]; TLorentzVector vSum; // Event loop for (Int_t i = 0; i < nev; ++i) { dime->GenerateEvent(); Int_t np = dime->ImportParticles(particles, "All"); printf("\n DIME Event %d: Imported %3d particles \n", i, np); Int_t nPrimary = 0; // Loop over pion (j = 4,5) tracks for (Int_t j = 4; j < 6; ++j) { part = (TParticle*) particles->At(j); // Choose the particle part->Print(); part->Momentum(v[nPrimary]); // Copy content to v nPrimary++; } //particles.Clear(); // 4-vector sum vSum = v[0] + v[1]; // Fill pi+pi- histograms hM->Fill(vSum.M()); } // Save plots as pdf hM->Draw(); c1->SaveAs("massTDime.pdf"); }
//_____________________________________________________________________________ TParticle* amsvmc_MCStack::PopNextTrack(Int_t& itrack) { /// Get next particle for tracking from the stack. /// \return The popped particle object /// \param track The index of the popped track // cout<<"DEBUG: in PopNextTrack:"<<endl; itrack = -1; if (fStack.empty()) return 0; TParticle* particle = fStack.top(); fStack.pop(); if (!particle) return 0; fCurrentTrack = particle->GetSecondMother(); itrack = fCurrentTrack; // cout << "fCurrentTrack: " << fCurrentTrack << endl; // fCurrentTrack = particle->GetID(); // itrack = fCurrentTrack; return particle; }
void Kin2Txt() { AliRunLoader* rl = AliRunLoader::Open("galice.root"); rl->LoadKinematics(); rl->LoadHeader(); TH1* hM = new TH1D("hM", "TreeK;M#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}^{2}}", 100, 0., 2.); TH1* hPt = new TH1D("hPt", "TreeK;P_{T}#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}}", 100, 0., 1.); TH1* hY = new TH1D("hY", "TreeK;Y#(){#pi^{+}#pi^{-}}", 160,-8., 8.); std::ofstream ofs("rho0.txt"); AliStack *stack = NULL; TParticle *part = NULL; TLorentzVector v[2], vSum; for (Int_t i=0, n(rl->GetNumberOfEvents()); i<n; ++i) { rl->GetEvent(i); stack = rl->Stack(); Int_t nPrimary(0); for (Int_t j(0), m(stack->GetNtrack()); j<m; ++j) { part = stack->Particle(j); if (part->IsPrimary()) part->Momentum(v[nPrimary++]); } if (nPrimary != 2) { Printf("Error: nPrimary=%d != 2", nPrimary); continue; } vSum = v[0] + v[1]; hM->Fill(vSum.M()); hPt->Fill(vSum.Perp()); hY->Fill(vSum.Rapidity()); ofs << std::fixed << std::setprecision(4) << vSum.M() << " " << vSum.Perp() << " " << vSum.Rapidity() << " " << v[0].Eta() << " " << v[0].Px() << " " << v[0].Py() << " " << v[0].Pz() << " " << v[1].Eta() << " " << v[1].Px() << " " << v[1].Py() << " " << v[1].Pz() << std::endl; } hM->Draw(); c1->SaveAs("TreeK.pdf("); hPt->Draw(); c1->SaveAs("TreeK.pdf"); hY->Draw(); c1->SaveAs("TreeK.pdf)"); }
void TVolumeSource::FindPotentialMinimum(){ cout << "Sampling phase space "; const int N = 100000; int percent = 0; for (int i = 0; i < N; i++){ PrintPercent((double)i/N, percent); double t = fmc->UniformDist(0, fActiveTime); // dice start time int polarisation = fmc->DicePolarisation(fParticleName); // dice polarisation double x, y, z; RandomPointInSourceVolume(x, y, z); // dice point in source volume TParticle *p = TParticleSource::CreateParticle(t, x, y, z, 0, 0, 0, polarisation); // create dummy particle with Ekin = 0 double V = p->Hstart(); // potential at particle position equals its total energy if (V < MinPot) MinPot = V; // remember minimal potential delete p; ParticleCounter--; } cout << " minimal potential = " << MinPot << "eV\n"; }
void GetFinalDecayProducts(Int_t ind, IlcStack & stack , TArrayI & ar){ // Recursive algorithm to get the final decay products of a particle // // ind is the index of the particle in the IlcStack // stack is the particle stack from the generator // ar contains the indexes of the final decay products // ar[0] is the number of final decay products if (ind<0 || ind>stack.GetNtrack()) { cerr << "Invalid index of the particle " << ind << endl; return; } if (ar.GetSize()==0) { ar.Set(10); ar[0] = 0; } TParticle * part = stack.Particle(ind); Int_t iFirstDaughter = part->GetFirstDaughter(); if( iFirstDaughter<0) { // This particle is a final decay product, add its index to the array ar[0]++; if (ar.GetSize() <= ar[0]) ar.Set(ar.GetSize()+10); // resize if needed ar[ar[0]] = ind; return; } Int_t iLastDaughter = part->GetLastDaughter(); for (Int_t id=iFirstDaughter; id<=iLastDaughter;id++) { // Now search for final decay products of the daughters GetFinalDecayProducts(id,stack,ar); } }
Bool_t CheckESD(const char* gAliceFileName = "galice.root", const char* esdFileName = "AliESDs.root") { // check the content of the ESD // check values Int_t checkNGenLow = 1; Double_t checkEffLow = 0.5; Double_t checkEffSigma = 3; Double_t checkFakeHigh = 0.5; Double_t checkFakeSigma = 3; Double_t checkResPtInvHigh = 5; Double_t checkResPtInvSigma = 3; Double_t checkResPhiHigh = 10; Double_t checkResPhiSigma = 3; Double_t checkResThetaHigh = 10; Double_t checkResThetaSigma = 3; Double_t checkPIDEffLow = 0.5; Double_t checkPIDEffSigma = 3; Double_t checkResTOFHigh = 500; Double_t checkResTOFSigma = 3; Double_t checkPHOSNLow = 5; Double_t checkPHOSEnergyLow = 0.3; Double_t checkPHOSEnergyHigh = 1.0; Double_t checkEMCALNLow = 50; Double_t checkEMCALEnergyLow = 0.05; Double_t checkEMCALEnergyHigh = 1.0; Double_t checkMUONNLow = 1; Double_t checkMUONPtLow = 0.5; Double_t checkMUONPtHigh = 10.; Double_t cutPtV0 = 0.3; Double_t checkV0EffLow = 0.02; Double_t checkV0EffSigma = 3; Double_t cutPtCascade = 0.5; Double_t checkCascadeEffLow = 0.01; Double_t checkCascadeEffSigma = 3; // open run loader and load gAlice, kinematics and header AliRunLoader* runLoader = AliRunLoader::Open(gAliceFileName); if (!runLoader) { Error("CheckESD", "getting run loader from file %s failed", gAliceFileName); return kFALSE; } runLoader->LoadgAlice(); gAlice = runLoader->GetAliRun(); if (!gAlice) { Error("CheckESD", "no galice object found"); return kFALSE; } runLoader->LoadKinematics(); runLoader->LoadHeader(); // open the ESD file TFile* esdFile = TFile::Open(esdFileName); if (!esdFile || !esdFile->IsOpen()) { Error("CheckESD", "opening ESD file %s failed", esdFileName); return kFALSE; } AliESDEvent * esd = new AliESDEvent; TTree* tree = (TTree*) esdFile->Get("esdTree"); if (!tree) { Error("CheckESD", "no ESD tree found"); return kFALSE; } esd->ReadFromTree(tree); // efficiency and resolution histograms Int_t nBinsPt = 15; Float_t minPt = 0.1; Float_t maxPt = 3.1; TH1F* hGen = CreateHisto("hGen", "generated tracks", nBinsPt, minPt, maxPt, "p_{t} [GeV/c]", "N"); TH1F* hRec = CreateHisto("hRec", "reconstructed tracks", nBinsPt, minPt, maxPt, "p_{t} [GeV/c]", "N"); Int_t nGen = 0; Int_t nRec = 0; Int_t nFake = 0; TH1F* hResPtInv = CreateHisto("hResPtInv", "", 100, -10, 10, "(p_{t,rec}^{-1}-p_{t,sim}^{-1}) / p_{t,sim}^{-1} [%]", "N"); TH1F* hResPhi = CreateHisto("hResPhi", "", 100, -20, 20, "#phi_{rec}-#phi_{sim} [mrad]", "N"); TH1F* hResTheta = CreateHisto("hResTheta", "", 100, -20, 20, "#theta_{rec}-#theta_{sim} [mrad]", "N"); // PID Int_t partCode[AliPID::kSPECIES] = {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton}; const char* partName[AliPID::kSPECIES+1] = {"electron", "muon", "pion", "kaon", "proton", "other"}; Double_t partFrac[AliPID::kSPECIES] = {0.01, 0.01, 0.85, 0.10, 0.05}; Int_t identified[AliPID::kSPECIES+1][AliPID::kSPECIES]; for (Int_t iGen = 0; iGen < AliPID::kSPECIES+1; iGen++) { for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) { identified[iGen][iRec] = 0; } } Int_t nIdentified = 0; // dE/dx and TOF TH2F* hDEdxRight = new TH2F("hDEdxRight", "", 300, 0, 3, 100, 0, 400); hDEdxRight->SetStats(kFALSE); hDEdxRight->GetXaxis()->SetTitle("p [GeV/c]"); hDEdxRight->GetYaxis()->SetTitle("dE/dx_{TPC}"); hDEdxRight->SetMarkerStyle(kFullCircle); hDEdxRight->SetMarkerSize(0.4); TH2F* hDEdxWrong = new TH2F("hDEdxWrong", "", 300, 0, 3, 100, 0, 400); hDEdxWrong->SetStats(kFALSE); hDEdxWrong->GetXaxis()->SetTitle("p [GeV/c]"); hDEdxWrong->GetYaxis()->SetTitle("dE/dx_{TPC}"); hDEdxWrong->SetMarkerStyle(kFullCircle); hDEdxWrong->SetMarkerSize(0.4); hDEdxWrong->SetMarkerColor(kRed); TH1F* hResTOFRight = CreateHisto("hResTOFRight", "", 100, -1000, 1000, "t_{TOF}-t_{track} [ps]", "N"); TH1F* hResTOFWrong = CreateHisto("hResTOFWrong", "", 100, -1000, 1000, "t_{TOF}-t_{track} [ps]", "N"); hResTOFWrong->SetLineColor(kRed); // calorimeters TH1F* hEPHOS = CreateHisto("hEPHOS", "PHOS", 100, 0, 50, "E [GeV]", "N"); TH1F* hEEMCAL = CreateHisto("hEEMCAL", "EMCAL", 100, 0, 50, "E [GeV]", "N"); // muons TH1F* hPtMUON = CreateHisto("hPtMUON", "MUON", 100, 0, 20, "p_{t} [GeV/c]", "N"); // V0s and cascades TH1F* hMassK0 = CreateHisto("hMassK0", "K^{0}", 100, 0.4, 0.6, "M(#pi^{+}#pi^{-}) [GeV/c^{2}]", "N"); TH1F* hMassLambda = CreateHisto("hMassLambda", "#Lambda", 100, 1.0, 1.2, "M(p#pi^{-}) [GeV/c^{2}]", "N"); TH1F* hMassLambdaBar = CreateHisto("hMassLambdaBar", "#bar{#Lambda}", 100, 1.0, 1.2, "M(#bar{p}#pi^{+}) [GeV/c^{2}]", "N"); Int_t nGenV0s = 0; Int_t nRecV0s = 0; TH1F* hMassXi = CreateHisto("hMassXi", "#Xi", 100, 1.2, 1.5, "M(#Lambda#pi) [GeV/c^{2}]", "N"); TH1F* hMassOmega = CreateHisto("hMassOmega", "#Omega", 100, 1.5, 1.8, "M(#LambdaK) [GeV/c^{2}]", "N"); Int_t nGenCascades = 0; Int_t nRecCascades = 0; // loop over events for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) { runLoader->GetEvent(iEvent); // select simulated primary particles, V0s and cascades AliStack* stack = runLoader->Stack(); Int_t nParticles = stack->GetNtrack(); TArrayF vertex(3); runLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex); TObjArray selParticles; TObjArray selV0s; TObjArray selCascades; for (Int_t iParticle = 0; iParticle < nParticles; iParticle++) { TParticle* particle = stack->Particle(iParticle); if (!particle) continue; if (particle->Pt() < 0.001) continue; if (TMath::Abs(particle->Eta()) > 0.9) continue; TVector3 dVertex(particle->Vx() - vertex[0], particle->Vy() - vertex[1], particle->Vz() - vertex[2]); if (dVertex.Mag() > 0.0001) continue; switch (TMath::Abs(particle->GetPdgCode())) { case kElectron: case kMuonMinus: case kPiPlus: case kKPlus: case kProton: { if (particle->Pt() > minPt) { selParticles.Add(particle); nGen++; hGen->Fill(particle->Pt()); } break; } case kK0Short: case kLambda0: { if (particle->Pt() > cutPtV0) { nGenV0s++; selV0s.Add(particle); } break; } case kXiMinus: case kOmegaMinus: { if (particle->Pt() > cutPtCascade) { nGenCascades++; selCascades.Add(particle); } break; } default: break; } } // get the event summary data tree->GetEvent(iEvent); if (!esd) { Error("CheckESD", "no ESD object found for event %d", iEvent); return kFALSE; } // loop over tracks for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) { AliESDtrack* track = esd->GetTrack(iTrack); // select tracks of selected particles Int_t label = TMath::Abs(track->GetLabel()); if (label > stack->GetNtrack()) continue; // background TParticle* particle = stack->Particle(label); if (!selParticles.Contains(particle)) continue; if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) continue; if (track->GetConstrainedChi2() > 1e9) continue; selParticles.Remove(particle); // don't count multiple tracks nRec++; hRec->Fill(particle->Pt()); if (track->GetLabel() < 0) nFake++; // resolutions hResPtInv->Fill(100. * (TMath::Abs(track->GetSigned1Pt()) - 1./particle->Pt()) * particle->Pt()); hResPhi->Fill(1000. * (track->Phi() - particle->Phi())); hResTheta->Fill(1000. * (track->Theta() - particle->Theta())); // PID if ((track->GetStatus() & AliESDtrack::kESDpid) == 0) continue; Int_t iGen = 5; for (Int_t i = 0; i < AliPID::kSPECIES; i++) { if (TMath::Abs(particle->GetPdgCode()) == partCode[i]) iGen = i; } Double_t probability[AliPID::kSPECIES]; track->GetESDpid(probability); Double_t pMax = 0; Int_t iRec = 0; for (Int_t i = 0; i < AliPID::kSPECIES; i++) { probability[i] *= partFrac[i]; if (probability[i] > pMax) { pMax = probability[i]; iRec = i; } } identified[iGen][iRec]++; if (iGen == iRec) nIdentified++; // dE/dx and TOF Double_t time[AliPID::kSPECIES]; track->GetIntegratedTimes(time); if (iGen == iRec) { hDEdxRight->Fill(particle->P(), track->GetTPCsignal()); if ((track->GetStatus() & AliESDtrack::kTOFpid) != 0) { hResTOFRight->Fill(track->GetTOFsignal() - time[iRec]); } } else { hDEdxWrong->Fill(particle->P(), track->GetTPCsignal()); if ((track->GetStatus() & AliESDtrack::kTOFpid) != 0) { hResTOFWrong->Fill(track->GetTOFsignal() - time[iRec]); } } } // loop over muon tracks { for (Int_t iTrack = 0; iTrack < esd->GetNumberOfMuonTracks(); iTrack++) { AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack); Double_t ptInv = TMath::Abs(muonTrack->GetInverseBendingMomentum()); if (ptInv > 0.001) { hPtMUON->Fill(1./ptInv); } } } // loop over V0s for (Int_t iV0 = 0; iV0 < esd->GetNumberOfV0s(); iV0++) { AliESDv0* v0 = esd->GetV0(iV0); if (v0->GetOnFlyStatus()) continue; v0->ChangeMassHypothesis(kK0Short); hMassK0->Fill(v0->GetEffMass()); v0->ChangeMassHypothesis(kLambda0); hMassLambda->Fill(v0->GetEffMass()); v0->ChangeMassHypothesis(kLambda0Bar); hMassLambdaBar->Fill(v0->GetEffMass()); Int_t negLabel = TMath::Abs(esd->GetTrack(v0->GetNindex())->GetLabel()); if (negLabel > stack->GetNtrack()) continue; // background Int_t negMother = stack->Particle(negLabel)->GetMother(0); if (negMother < 0) continue; Int_t posLabel = TMath::Abs(esd->GetTrack(v0->GetPindex())->GetLabel()); if (posLabel > stack->GetNtrack()) continue; // background Int_t posMother = stack->Particle(posLabel)->GetMother(0); if (negMother != posMother) continue; TParticle* particle = stack->Particle(negMother); if (!selV0s.Contains(particle)) continue; selV0s.Remove(particle); nRecV0s++; } // loop over Cascades for (Int_t iCascade = 0; iCascade < esd->GetNumberOfCascades(); iCascade++) { AliESDcascade* cascade = esd->GetCascade(iCascade); Double_t v0q; cascade->ChangeMassHypothesis(v0q,kXiMinus); hMassXi->Fill(cascade->GetEffMassXi()); cascade->ChangeMassHypothesis(v0q,kOmegaMinus); hMassOmega->Fill(cascade->GetEffMassXi()); Int_t negLabel = TMath::Abs(esd->GetTrack(cascade->GetNindex()) ->GetLabel()); if (negLabel > stack->GetNtrack()) continue; // background Int_t negMother = stack->Particle(negLabel)->GetMother(0); if (negMother < 0) continue; Int_t posLabel = TMath::Abs(esd->GetTrack(cascade->GetPindex()) ->GetLabel()); if (posLabel > stack->GetNtrack()) continue; // background Int_t posMother = stack->Particle(posLabel)->GetMother(0); if (negMother != posMother) continue; Int_t v0Mother = stack->Particle(negMother)->GetMother(0); if (v0Mother < 0) continue; Int_t bacLabel = TMath::Abs(esd->GetTrack(cascade->GetBindex()) ->GetLabel()); if (bacLabel > stack->GetNtrack()) continue; // background Int_t bacMother = stack->Particle(bacLabel)->GetMother(0); if (v0Mother != bacMother) continue; TParticle* particle = stack->Particle(v0Mother); if (!selCascades.Contains(particle)) continue; selCascades.Remove(particle); nRecCascades++; } // loop over the clusters { for (Int_t iCluster=0; iCluster<esd->GetNumberOfCaloClusters(); iCluster++) { AliESDCaloCluster * clust = esd->GetCaloCluster(iCluster); if (clust->IsPHOS()) hEPHOS->Fill(clust->E()); if (clust->IsEMCAL()) hEEMCAL->Fill(clust->E()); } } } // perform checks if (nGen < checkNGenLow) { Warning("CheckESD", "low number of generated particles: %d", Int_t(nGen)); } TH1F* hEff = CreateEffHisto(hGen, hRec); Info("CheckESD", "%d out of %d tracks reconstructed including %d " "fake tracks", nRec, nGen, nFake); if (nGen > 0) { // efficiency Double_t eff = nRec*1./nGen; Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGen); Double_t fake = nFake*1./nGen; Double_t fakeError = TMath::Sqrt(fake*(1.-fake) / nGen); Info("CheckESD", "eff = (%.1f +- %.1f) %% fake = (%.1f +- %.1f) %%", 100.*eff, 100.*effError, 100.*fake, 100.*fakeError); if (eff < checkEffLow - checkEffSigma*effError) { Warning("CheckESD", "low efficiency: (%.1f +- %.1f) %%", 100.*eff, 100.*effError); } if (fake > checkFakeHigh + checkFakeSigma*fakeError) { Warning("CheckESD", "high fake: (%.1f +- %.1f) %%", 100.*fake, 100.*fakeError); } // resolutions Double_t res, resError; if (FitHisto(hResPtInv, res, resError)) { Info("CheckESD", "relative inverse pt resolution = (%.1f +- %.1f) %%", res, resError); if (res > checkResPtInvHigh + checkResPtInvSigma*resError) { Warning("CheckESD", "bad pt resolution: (%.1f +- %.1f) %%", res, resError); } } if (FitHisto(hResPhi, res, resError)) { Info("CheckESD", "phi resolution = (%.1f +- %.1f) mrad", res, resError); if (res > checkResPhiHigh + checkResPhiSigma*resError) { Warning("CheckESD", "bad phi resolution: (%.1f +- %.1f) mrad", res, resError); } } if (FitHisto(hResTheta, res, resError)) { Info("CheckESD", "theta resolution = (%.1f +- %.1f) mrad", res, resError); if (res > checkResThetaHigh + checkResThetaSigma*resError) { Warning("CheckESD", "bad theta resolution: (%.1f +- %.1f) mrad", res, resError); } } // PID if (nRec > 0) { Double_t eff = nIdentified*1./nRec; Double_t effError = TMath::Sqrt(eff*(1.-eff) / nRec); Info("CheckESD", "PID eff = (%.1f +- %.1f) %%", 100.*eff, 100.*effError); if (eff < checkPIDEffLow - checkPIDEffSigma*effError) { Warning("CheckESD", "low PID efficiency: (%.1f +- %.1f) %%", 100.*eff, 100.*effError); } } printf("%9s:", "gen\\rec"); for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) { printf("%9s", partName[iRec]); } printf("\n"); for (Int_t iGen = 0; iGen < AliPID::kSPECIES+1; iGen++) { printf("%9s:", partName[iGen]); for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) { printf("%9d", identified[iGen][iRec]); } printf("\n"); } if (FitHisto(hResTOFRight, res, resError)) { Info("CheckESD", "TOF resolution = (%.1f +- %.1f) ps", res, resError); if (res > checkResTOFHigh + checkResTOFSigma*resError) { Warning("CheckESD", "bad TOF resolution: (%.1f +- %.1f) ps", res, resError); } } // calorimeters if (hEPHOS->Integral() < checkPHOSNLow) { Warning("CheckESD", "low number of PHOS particles: %d", Int_t(hEPHOS->Integral())); } else { Double_t mean = hEPHOS->GetMean(); if (mean < checkPHOSEnergyLow) { Warning("CheckESD", "low mean PHOS energy: %.1f GeV", mean); } else if (mean > checkPHOSEnergyHigh) { Warning("CheckESD", "high mean PHOS energy: %.1f GeV", mean); } } if (hEEMCAL->Integral() < checkEMCALNLow) { Warning("CheckESD", "low number of EMCAL particles: %d", Int_t(hEEMCAL->Integral())); } else { Double_t mean = hEEMCAL->GetMean(); if (mean < checkEMCALEnergyLow) { Warning("CheckESD", "low mean EMCAL energy: %.1f GeV", mean); } else if (mean > checkEMCALEnergyHigh) { Warning("CheckESD", "high mean EMCAL energy: %.1f GeV", mean); } } // muons if (hPtMUON->Integral() < checkMUONNLow) { Warning("CheckESD", "low number of MUON particles: %d", Int_t(hPtMUON->Integral())); } else { Double_t mean = hPtMUON->GetMean(); if (mean < checkMUONPtLow) { Warning("CheckESD", "low mean MUON pt: %.1f GeV/c", mean); } else if (mean > checkMUONPtHigh) { Warning("CheckESD", "high mean MUON pt: %.1f GeV/c", mean); } } // V0s if (nGenV0s > 0) { Double_t eff = nRecV0s*1./nGenV0s; Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGenV0s); if (effError == 0) effError = checkV0EffLow / TMath::Sqrt(1.*nGenV0s); Info("CheckESD", "V0 eff = (%.1f +- %.1f) %%", 100.*eff, 100.*effError); if (eff < checkV0EffLow - checkV0EffSigma*effError) { Warning("CheckESD", "low V0 efficiency: (%.1f +- %.1f) %%", 100.*eff, 100.*effError); } } // Cascades if (nGenCascades > 0) { Double_t eff = nRecCascades*1./nGenCascades; Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGenCascades); if (effError == 0) effError = checkV0EffLow / TMath::Sqrt(1.*nGenCascades); Info("CheckESD", "Cascade eff = (%.1f +- %.1f) %%", 100.*eff, 100.*effError); if (eff < checkCascadeEffLow - checkCascadeEffSigma*effError) { Warning("CheckESD", "low Cascade efficiency: (%.1f +- %.1f) %%", 100.*eff, 100.*effError); } } } // draw the histograms if not in batch mode if (!gROOT->IsBatch()) { new TCanvas; hEff->DrawCopy(); new TCanvas; hResPtInv->DrawCopy("E"); new TCanvas; hResPhi->DrawCopy("E"); new TCanvas; hResTheta->DrawCopy("E"); new TCanvas; hDEdxRight->DrawCopy(); hDEdxWrong->DrawCopy("SAME"); new TCanvas; hResTOFRight->DrawCopy("E"); hResTOFWrong->DrawCopy("SAME"); new TCanvas; hEPHOS->DrawCopy("E"); new TCanvas; hEEMCAL->DrawCopy("E"); new TCanvas; hPtMUON->DrawCopy("E"); new TCanvas; hMassK0->DrawCopy("E"); new TCanvas; hMassLambda->DrawCopy("E"); new TCanvas; hMassLambdaBar->DrawCopy("E"); new TCanvas; hMassXi->DrawCopy("E"); new TCanvas; hMassOmega->DrawCopy("E"); } // write the output histograms to a file TFile* outputFile = TFile::Open("check.root", "recreate"); if (!outputFile || !outputFile->IsOpen()) { Error("CheckESD", "opening output file check.root failed"); return kFALSE; } hEff->Write(); hResPtInv->Write(); hResPhi->Write(); hResTheta->Write(); hDEdxRight->Write(); hDEdxWrong->Write(); hResTOFRight->Write(); hResTOFWrong->Write(); hEPHOS->Write(); hEEMCAL->Write(); hPtMUON->Write(); hMassK0->Write(); hMassLambda->Write(); hMassLambdaBar->Write(); hMassXi->Write(); hMassOmega->Write(); outputFile->Close(); delete outputFile; // clean up delete hGen; delete hRec; delete hEff; delete hResPtInv; delete hResPhi; delete hResTheta; delete hDEdxRight; delete hDEdxWrong; delete hResTOFRight; delete hResTOFWrong; delete hEPHOS; delete hEEMCAL; delete hPtMUON; delete hMassK0; delete hMassLambda; delete hMassLambdaBar; delete hMassXi; delete hMassOmega; delete esd; esdFile->Close(); delete esdFile; runLoader->UnloadHeader(); runLoader->UnloadKinematics(); delete runLoader; // result of check Info("CheckESD", "check of ESD was successfull"); return kTRUE; }
//________________________________________________________________________________ void StarMCHits::FinishEvent() { static const Double_t pEMax = 1 - 1.e-10; TDataSet *m_DataSet = StarMCHits::instance()->GetHitHolder(); if (! m_DataSet) return; St_g2t_event *g2t_event = new St_g2t_event("g2t_event",1); m_DataSet->Add(g2t_event); g2t_event_st event; memset (&event, 0, sizeof(g2t_event_st)); fEventNumber++; event.n_event = fEventNumber;//IHEAD(2) event.ge_rndm[0] = fSeed;//IHEAD(3) event.ge_rndm[1] = 0;//IHEAD(4) event.n_run = 1; event.n_track_eg_fs = StarVMCApplication::Instance()->GetStack()->GetNtrack(); event.n_track_prim = StarVMCApplication::Instance()->GetStack()->GetNprimary(); event.prim_vertex_p = 1; event.b_impact = 99; event.phi_impact = 0.5; g2t_event->AddAt(&event); Int_t NoVertex = 1; St_g2t_vertex *g2t_vertex = new St_g2t_vertex("g2t_vertex",NoVertex); m_DataSet->Add(g2t_vertex); g2t_vertex_st vertex; Int_t NTracks = StarVMCApplication::Instance()->GetStack()->GetNtrack(); St_g2t_track *g2t_track = new St_g2t_track ("g2t_track",NTracks); m_DataSet->Add(g2t_track); g2t_track_st track; StarMCParticle *particle = 0; Int_t iv = 0; TLorentzVector oldV(0,0,0,0); TLorentzVector newV(0,0,0,0); TLorentzVector devV(0,0,0,0); for (Int_t it = 0; it <NTracks; it++) { memset(&track, 0, sizeof(g2t_track_st)); particle = (StarMCParticle*) StarVMCApplication::Instance()->GetStack()->GetParticle(it); TParticle *part = (TParticle *) particle->GetParticle(); part->ProductionVertex(newV); devV = newV - oldV; if (iv == 0 || devV.Mag() > 1.e-7) { if (iv > 0) g2t_vertex->AddAt(&vertex); memset (&vertex, 0, sizeof(g2t_vertex_st)); iv++; vertex.id = iv ;// primary key vertex.event_p = 0 ;// pointer to event vertex.eg_label = 0 ;// generator label (0 if GEANT) vertex.eg_tof = 0 ;// vertex production time vertex.eg_proc = 0 ;// event generator mechanism memcpy(vertex.ge_volume," ",4); ;// GEANT volume name vertex.ge_medium = 0 ;// GEANT Medium vertex.ge_tof = 0 ;// GEANT vertex production time vertex.ge_proc = 0 ;// GEANT mechanism (0 if eg) vertex.ge_x[0] = newV.X() ;// GEANT vertex coordinate vertex.ge_x[1] = newV.Y() ; vertex.ge_x[2] = newV.Z() ; vertex.ge_tof = newV.T() ; vertex.n_parent = 0 ;// number of parent tracks vertex.parent_p = 0 ;// first parent track vertex.is_itrmd = 0 ;// flags intermediate vertex vertex.next_itrmd_p = 0 ;// next intermedate vertex vertex.next_prim_v_p= 0 ;// next primary vertex oldV = newV; } vertex.n_daughter++; track.id = it+1; track.eg_label = particle->GetIdGen(); track.eg_pid = part->GetPdgCode(); track.ge_pid = gMC->IdFromPDG(track.eg_pid); track.start_vertex_p = iv; track.p[0] = part->Px(); track.p[1] = part->Py(); track.p[2] = part->Pz(); track.ptot = part->P(); track.e = part->Energy(); track.charge = part->GetPDG()->Charge()/3; Double_t ratio = part->Pz()/part->Energy(); ratio = TMath::Min(1.-1e-10,TMath::Max(-1.+1e-10, ratio)); track.rapidity = TMath::ATanH(ratio); track.pt = part->Pt(); ratio = part->Pz()/part->P(); ratio = TMath::Min(pEMax,TMath::Max(-pEMax, ratio)); track.eta = TMath::ATanH(ratio); g2t_track->AddAt(&track); } g2t_vertex->AddAt(&vertex); }
void pythia6_gammagamma_leptons_parents( int Nevts = 5000, double sqrts = 90, int MSTP14_val=10) { //Luminosity and bunches definitions according to FCC-ee project specifications Double_t Luminosity=1; Double_t Luminosity_c=1; //with opt crab waist Double_t FCC_Circumference = 100000; // meters Double_t speed_of_light = 299792458; // m/s Int_t N_bunch = 1; //number of bunches per beam Int_t N_bunch_c= 1;//with opt Crab waist if (sqrts==90){ N_bunch = 16700; Luminosity = 0.28; //pb^-1 s^-1 N_bunch_c = 59581; Luminosity_c = 2.15; } else if (sqrts==160){ N_bunch = 4490; Luminosity = 0.12; //pb^-1 s^-1 N_bunch_c =3143; Luminosity_c =0.38; } else if (sqrts==240){ N_bunch = 1360; Luminosity = 0.06; //pb^-1 s^-1 N_bunch_c = 625; Luminosity_c = 0.087; } else if (sqrts==350){ N_bunch = 98; Luminosity = 0.0018; //pb^-1 s^-1 N_bunch_c = 68; Luminosity_c = 0.021; } // Instance of the Pythia event generator TPythia6* pythia = new TPythia6(); PDG = TDatabasePDG::Instance(); // TDataBasePDG contains info on all particle properties // Random seeding int seed = (int)(time(NULL)/3); if( (seed>=0) && (seed<=900000000) ) { pythia->SetMRPY(1,seed); // set seed pythia->SetMRPY(2,0); // use new seed cout << endl << "<I> Random Seed : " << seed << endl; } else{ cout << endl << "<I> Default random seed ... "<< seed << endl; } //____________________________________________________________________ // // PYTHIA GENERATION SETTINGS //____________________________________________________________________ // ******************************************************************* // PHYSICS PROCESS SELECTION pythia->SetMSEL(0); // we choose the process by hand below pythia->SetMSTP(81, 1); // Multiple parton interactions for resolved gamma-gamma colls. // ******************************************************************* // Final-state: pythia->SetMSTJ(22,2); //! Decay those unstable particles', pythia->SetPARJ(71,10.); //! for which ctau < 10 mm', // ******************************************************************* // Detailed process selection pythia->SetMSTP(14,MSTP14_val); // gamma gamma -> hadrons (30=FULL) //pythia->SetMSEL(2); // min-bias QCD pythia->SetMSEL(1); //less accuracy in hadronic simulation but faster(usefull if intereted in leptonic) // ****************************************************************** book_histos(); // ****************************************************************** // Initialise it to run e+/e- --> gamma gamma --> X pythia->Initialize("cms", "gamma/e+", "gamma/e-", sqrts); //pythia->Initialize("cms", "e+", "e-", sqrts); cout << "SYSTEM: e+e- at sqrt(s)=" << sqrts << " GeV" << endl; TClonesArray* particlesArray = 0; // ****************************************************************** // EVENT LOOP int exclEvts = 0; std::ofstream myfile; myfile.open("_txt/generation_time.txt"); int execution_time[Nevts/1000]; Int_t n_lepton_total=0; //counter for the total number of charged leptons (sum on the events) for (int ievt = 0; ievt < Nevts; ievt++) { if (ievt ==0) cout << "Generating event #: " << flush; if (ievt % 1000 == 0) { cout << ievt << " " << flush; execution_time[ievt/1000]=time(NULL); if (ievt !=0) myfile << execution_time[ievt/1000] << "\t" << ievt << "\t" << 1000/(float)(execution_time[ievt/1000]-execution_time[ievt/1000 -1])<< endl; } // ****************************************************************** // Generate event pythia->GenerateEvent(); if ( passEvtSelection(pythia)==false ) { ///Cut on W!!!!!!!!!!!!!!! exclEvts++; continue; } // Loop over particles and fill histos particlesArray = (TClonesArray*)pythia->GetListOfParticles(); int N = particlesArray->GetEntriesFast(); //cout << "<I> PYTHIA particles in event: " << N << " " << flush; TMCParticle *part; TParticle *partic; Int_t n_leptons = 0; for (int ip = 0; ip < N; ip++ ) { part = (TMCParticle*)particlesArray->At(ip); int status = part->GetKS(); if (status!=1) continue; // Only consider final-state particles int parent_id = part->GetParent(); //if (parent_id != 22) continue; //Only consider particles coming from photons int pdg = part->GetKF(); double charge = PDG->GetParticle(pdg)->Charge(); if(charge==0) continue; // only charged particles //if ( abs(pdg)!=11 && abs(pdg)!=13 ) continue;// only leptons if ( abs(pdg)!=13 ) continue;// only muons partic = (TParticle*)TMCParticle2TParticle(part); double ptPartic = partic->Pt(); double etaPartic = partic->Eta(); //phiPartic = partic->Phi(); //if ( ptPartic<0.15 ) continue; //cut on Pt!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //if (abs(etaPartic)>1.5) continue; //Fill only if |eta|<1.5!!!!!!!!!!!!!!!!!!!!! // Histo filling h_id_part->Fill(abs(pdg)); hdsigmadeta->Fill(etaPartic); hdsigmadpT->Fill(ptPartic); n_leptons++; //Count the total number of charged hadrons in this event delete partic; // if (TMath::Abs(etaPartic)<1.) Nch++; } // End loop over all particles in event h_lep_per_ev->Fill(n_leptons); n_lepton_total += n_leptons; } // END EVENT GENERATION LOOP myfile.close(); // ********************************************************************************** // FINAL GENERATION MESSAGES: pythia->Pystat(1); double xsection = pythia->GetPARI(1) * 1e9;//conversion form mb to pb int ntrials = pythia->GetMSTI(5); double sigmaweight = xsection/ntrials; double total_lepton_xsection = sigmaweight*n_lepton_total; cout << endl << "#######################" << endl << endl << "<I> Event summary: " << Nevts << " generated." << endl ; //double evts = hdsigmadeta->Integral(); double triggEff = (Nevts-exclEvts)/(float)Nevts; cout << "<I> Num. of total valid events = " << Nevts-exclEvts << " (Effic="<< triggEff*100. << "%)" << endl; cout << "<I> Pythia cross section: " << xsection << " mb || number of trials: " << ntrials << " || sigmaweight = "<< sigmaweight <<endl; cout << endl << "Leptons per events: " << endl << "Mean = " << h_lep_per_ev->GetMean() << endl << "Max = " << h_lep_per_ev->GetMaximumBin() <<endl; cout << endl << endl << endl << "Total number of leptons = " << n_lepton_total << endl; cout << "Cross section = " << total_lepton_xsection << "pb in e+e- --> gamma gamma --> X at sqrt(s) = " << sqrts << " GeV " << endl << endl << endl; Double_t N_rate = total_lepton_xsection*Luminosity; Double_t Pileup = (N_rate*FCC_Circumference)/(N_bunch*speed_of_light); Double_t N_rate_c = total_lepton_xsection*Luminosity_c; Double_t Pileup_c = (N_rate_c*FCC_Circumference)/(N_bunch_c*speed_of_light); ofstream file_out; char file_out_name[150]; sprintf(file_out_name, "_txt/pythia6_gammagamma_leptons_%iGeV_seed%d_Nevts%d_output.txt",(int)TMath::Ceil(sqrts),seed,Nevts); file_out.open(file_out_name); file_out << Nevts-exclEvts << " // Total event generated" << endl; file_out << xsection << " // [pb] Pythia6 total cross section" << endl; file_out << total_lepton_xsection << " // [pb] Cross section for e+e- --> gamma gamma --> l"<< endl; file_out << sqrts << " // [GeV] sqrt(s)" << endl; file_out << n_lepton_total <<" // Total Lepton produced" << endl; file_out << N_rate << " // [Hz] Production Rate (Sigma*Lum)" << endl; file_out << N_rate_c << " // [Hz] Production Rate (Sigma*Lum) (Crab waist)" << endl << endl << endl; file_out << Pileup << " // Interactions e/gamma e/gamma -> l per bunch" << endl; file_out << Pileup_c << " // Interactions e/gamma e/gamma -> l per bunch (Crab Waist)" << endl; file_out.close(); // double dNchdeta = hdsigmadeta->GetBinContent(11)/ntrials; // cout << "<I> dN_ch/deta|_{eta=0} = " << dNchdeta << " in e+e- --> gamma gamma --> X at sqrt(s) = " << sqrts << " GeV " << endl ; // ********************************************************************************** // Normalize histos by weighted cross-section, pseudorapidity range, and the pT bin size hdNdeta=(TH1F*)hdsigmadeta->Clone("hdNdeta"); hdNdeta->Scale(1./(float)Nevts); hdNdeta->SetTitle("hdNdeta"); hdNdeta->SetXTitle("|#eta|"); hdNdeta->SetYTitle("dN/d|#eta| (nb)"); double etabinsize = 20/20; // eta binning: 20 within -10<eta<10 hdsigmadeta->Scale(1e-3*sigmaweight/etabinsize); //hdsigmadeta->Scale(1/Nevts); double ptbinsize = (pt_max-pt_min)/n_bin_pt; hdsigmadpT->Scale(sigmaweight/ptbinsize); //hdsigmadetaTruth->Scale(sigmaweight*0.01); // eta binning: 2000 in -10<eta<10 //hEdsigmadpT->Scale(ptbinsize/ntrials); //ntFFdsigmadeta->SetWeight(sigmaweight); // ********************************************************************************** // Plot distributions for cross-check char title[300]; sprintf(title, "cinvdsigmadpT_%iGeV",(int)sqrts); TCanvas *cinvdsigmadpT = new TCanvas(title,title,700,600); cinvdsigmadpT->SetLogy(); cinvdsigmadpT->SetLogx(); cinvdsigmadpT->cd(); hdsigmadpT->Draw(); cinvdsigmadpT->SaveAs("_png/histo_hdsigmadpT.png"); sprintf(title, "cinvdsigmadeta_%iGeV",(int)sqrts); TCanvas *cinvdsigmadeta = new TCanvas(title,title,700,600); cinvdsigmadeta->cd(); hdsigmadeta->Draw(); cinvdsigmadeta->SaveAs("_png/histo_hdsigmadeta.png"); sprintf(title, "cinvdNdeta_%iGeV",(int)sqrts); TCanvas *cinvdNdeta = new TCanvas(title,title,700,600); cinvdNdeta->cd(); hdNdeta->Draw(); cinvdNdeta->SaveAs("_png/histo_hdNdeta.png"); sprintf(title, "cinvW_%iGeV",(int)sqrts); TCanvas *cinvW = new TCanvas(title,title,700,600); cinvW->cd(); hW->Draw(); cinvW->SaveAs("_png/histo_hW.png"); sprintf(title, "cinvn_lep_%iGeV",(int)sqrts); TCanvas *cinvn_lep = new TCanvas(title,title,700,600); cinvn_lep->cd(); h_lep_per_ev->Draw(); cinvn_lep->SetLogy(); cinvn_lep->SetGridx(); cinvn_lep->SetGridy(); cinvn_lep->SaveAs("_png/histo_charged_leptons_per_ev.png"); sprintf(title, "cinvp_id_%iGeV",(int)sqrts); TCanvas *cinvp_id = new TCanvas(title,title,700,600); cinvp_id->cd(); cinvp_id->SetLogy(); h_id_part->Draw(); cinvp_id->SaveAs("_png/histo_particle_id.png"); // ********************************************************************************** // Open output file and Close file char filename[200]; sprintf(filename, "_root/pythia6_gammagamma_leptons_%iGeV_seed%d_Nevts%d.root",(int)TMath::Ceil(sqrts),seed,Nevts); TFile* file = TFile::Open(filename, "RECREATE"); if (!file || !file->IsOpen()) { Error("pythia6_gammagamma_leptons", "Couldn;t open file %s", filename); return; } file->cd(); hdsigmadeta->Write(); hdsigmadpT->Write(); hdNdeta->Write(); h_lep_per_ev->Write(); hW->Write(); h_id_part->Write(); file->Close(); cout << endl << "#######<I> File " << filename << " created. Take a look ... ##############" << endl << endl; file = TFile::Open(filename); file->ls(); file->Close(); }
void createGlauberTree(Int_t nEvents, const char *outFileName) { AliPDG::AddParticlesToPdgDataBase(); TDatabasePDG::Instance(); // Run loader TFolder *folder = new TFolder("myfolder","myfolder"); AliRunLoader* rl = new AliRunLoader(folder); rl->MakeHeader(); rl->MakeStack(); AliStack* stack = rl->Stack(); //AliHeader* rheader = rl->GetHeader(); AliGenHijing *genHi = new AliGenHijing(-1); genHi->SetStack(stack); genHi->SetEnergyCMS(2760); genHi->SetReferenceFrame("CMS"); genHi->SetProjectile("A", 208, 82); genHi->SetTarget ("A", 208, 82); genHi->SetPtHardMin (2.3); genHi->SetImpactParameterRange(0.,30); genHi->SetJetQuenching(0); // enable jet quenching genHi->SetShadowing(1); // enable shadowing genHi->SetDecaysOff(1); // neutral pion and heavy particle decays switched off genHi->Init(); MyHeader *myheader = new MyHeader; MyResponse *myresp = new MyResponse; TFile *outFile = TFile::Open(outFileName, "RECREATE"); outFile->SetCompressionLevel(5); TDirectory::TContext context(outFile); TTree *tree = new TTree("glaubertree", "Glauber tree"); tree->Branch("header",&myheader, 32*1024, 99); tree->Branch("response",&myresp, 32*1024, 99); TNtuple *ntuple = new TNtuple("gnt", "Glauber ntuple", "npart:ncoll:b"); Double_t etas[] = {-10,-5,-4,-3,-2,-1,0,1,2,3,4,5,10}; TH1D *hNEta = new TH1D("hNeta","",12,etas); TH1D *hEtEta = new TH1D("hEteta","",12,etas); // create events and fill them for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) { cout << "Event " << iEvent+1 << "/" << nEvents << endl;; stack->Reset(); hNEta->Reset(); hEtEta->Reset(); genHi->Generate(); AliStack *s = genHi->GetStack(); const TObjArray *parts = s->Particles(); Int_t nents = parts->GetEntries(); for (Int_t i = 0; i<nents; ++i) { TParticle *p = (TParticle*)parts->At(i); //p->Print(); TParticlePDG *pdg = p->GetPDG(1); Int_t c = (Int_t)(TMath::Abs(pdg->Charge())); if (c!=0) { hNEta->Fill(p->Eta()); hEtEta->Fill(p->Eta(),p->Pt()); } } AliGenHijingEventHeader *h = (AliGenHijingEventHeader*)genHi->CollisionGeometry(); myheader->fNATT = nents; myheader->fEATT = h->TotalEnergy(); myheader->fJATT = h->HardScatters(); myheader->fNT = h->TargetParticipants(); myheader->fNP = h->ProjectileParticipants(); myheader->fN00 = h->NwNw(); myheader->fN01 = h->NwN(); myheader->fN10 = h->NNw(); myheader->fN11 = h->NN(); myheader->fBB = h->ImpactParameter(); myheader->fRP = h->ReactionPlaneAngle(); myheader->fPSn = h->ProjSpectatorsn(); myheader->fPSp = h->ProjSpectatorsp(); myheader->fTSn = h->TargSpectatorsn(); myheader->fTSp = h->TargSpectatorsn(); myresp->fEtch0p = hEtEta->GetBinContent(hEtEta->FindBin(0.5)); myresp->fEtch1p = hEtEta->GetBinContent(hEtEta->FindBin(1.5)); myresp->fEtch2p = hEtEta->GetBinContent(hEtEta->FindBin(2.5)); myresp->fEtch3p = hEtEta->GetBinContent(hEtEta->FindBin(3.5)); myresp->fEtch4p = hEtEta->GetBinContent(hEtEta->FindBin(4.5)); myresp->fEtch5p = hEtEta->GetBinContent(hEtEta->FindBin(5.5)); myresp->fEtchrp = hEtEta->GetBinContent(hEtEta->FindBin(10.5)); myresp->fEtch0n = hEtEta->GetBinContent(hEtEta->FindBin(-0.5)); myresp->fEtch1n = hEtEta->GetBinContent(hEtEta->FindBin(-1.5)); myresp->fEtch2n = hEtEta->GetBinContent(hEtEta->FindBin(-2.5)); myresp->fEtch3n = hEtEta->GetBinContent(hEtEta->FindBin(-3.5)); myresp->fEtch4n = hEtEta->GetBinContent(hEtEta->FindBin(-4.5)); myresp->fEtch5n = hEtEta->GetBinContent(hEtEta->FindBin(-5.5)); myresp->fEtchrn = hEtEta->GetBinContent(hEtEta->FindBin(-10.5)); myresp->fNch0p = hNEta->GetBinContent(hNEta->FindBin(0.5)); myresp->fNch1p = hNEta->GetBinContent(hNEta->FindBin(1.5)); myresp->fNch2p = hNEta->GetBinContent(hNEta->FindBin(2.5)); myresp->fNch3p = hNEta->GetBinContent(hNEta->FindBin(3.5)); myresp->fNch4p = hNEta->GetBinContent(hNEta->FindBin(4.5)); myresp->fNch5p = hNEta->GetBinContent(hNEta->FindBin(5.5)); myresp->fNchrp = hNEta->GetBinContent(hNEta->FindBin(10.5)); myresp->fNch0n = hNEta->GetBinContent(hNEta->FindBin(-0.5)); myresp->fNch1n = hNEta->GetBinContent(hNEta->FindBin(-1.5)); myresp->fNch2n = hNEta->GetBinContent(hNEta->FindBin(-2.5)); myresp->fNch3n = hNEta->GetBinContent(hNEta->FindBin(-3.5)); myresp->fNch4n = hNEta->GetBinContent(hNEta->FindBin(-4.5)); myresp->fNch5n = hNEta->GetBinContent(hNEta->FindBin(-5.5)); myresp->fNchrn = hNEta->GetBinContent(hNEta->FindBin(-10.5)); tree->Fill(); if (ntuple) { Int_t np = h->TargetParticipants() + h->ProjectileParticipants(); Int_t nc = h->NwNw() + h->NwN() + h->NNw() + h->NN(); Double_t b = h->ImpactParameter(); ntuple->Fill(np,nc,b); } } // end of event loop tree->Write(); ntuple->Write(); outFile->Close(); }
Int_t TOFquickanal(Int_t eventNumber = 0) { ///////////////////////////////////////////////////////////////////////// // This macro is a small example of a ROOT macro // illustrating how to read the output of GALICE // and fill some histograms concerning the TOF Hit Tree. // // Root > .L TOFquickanal.C //this loads the macro in memory // Root > TOFquickanal(); //by default process first event // Root > TOFquickanal(2); //process third event //Begin_Html /* <img src="picts/TOFquickanal.gif"> */ //End_Html // // Author: F. Pierella , Bologna University 12-04-2001 // Updated to the new I/O by: A. De Caro, C. Zampolli ///////////////////////////////////////////////////////////////////////// // Dynamically link some shared libs if (gClassTable->GetID("AliRun") < 0) { gROOT->LoadMacro("loadlibs.C"); loadlibs(); } Int_t rc = 0; AliRunLoader *rl =AliRunLoader::Open("galice.root",AliConfig::GetDefaultEventFolderName(),"update"); if (!rl) { cerr << "Can't load RunLoader from file!\n"; rc = 1; return rc; } rl->LoadgAlice(); gAlice=rl->GetAliRun(); if (!gAlice) { cerr << "<TOFquickanal> AliRun object not found on file \n"; rc = 2; return rc; } // Get the pointer to the TOF detector AliLoader *tofl = rl->GetLoader("TOFLoader"); AliTOF * tof = (AliTOF*) gAlice->GetDetector("TOF"); if (tof == 0x0 || tofl == 0x0) { cerr << "<TOFquickanal> Can not find TOF or TOFLoader\n"; rc = 3; return rc; } //=======> Create histograms //---> Time of Flight for Primary Particles (ns) TH1F *htofprim = new TH1F("htofprim","Time of Flight for Primary Particles",100,0.,100.); //--->Time of Flight for Secondary Particles (ns) TH1F *htofsec = new TH1F("htofsec","Time of Flight for Secondary Particles",100,0.,100.); //---> r (radius) coordinate of production in the ALICE frame for secondary particles that produce at // least one TOF-hit (cm) - cylindrical coordinate system assumed, primary plus secondary- TH1F *hradius = new TH1F("hradius","r (radius) coordinate at the production vertex for secondary particles with at least one TOF-Hit",50,0.,500.); //---> Momentum of primary particles that produce (at least) one TOF-hit when the hit // is produced (Gev/c) TH1F *htofmom = new TH1F("htofmom","Momentum of primary particles when the Hit is produced",50,0.,5.); //---> Momentum of primary particles that produce (at least) one TOF-hit at the production vertex // (Gev/c) TH1F *hprodmom = new TH1F("hprodmom","Momentum of primary particles (with at least one TOF hit) at the production ",50,0.,5.); //---> Theta of production for primary particles that produce (at least) one TOF-hit (deg) TH1F *hprodthe = new TH1F("hprodthe","Theta of primary particles (with at least one TOF hit) at the production ",90,0.,180.); //---> Phi of production for primary particles that produce (at least) one TOF-hit (deg) TH1F *hprodphi = new TH1F("hprodphi","Phi of primary particles (with at least one TOF hit) at the production ",180,-180.,180.); //---> z Coordinate of the TOF Hit (z beam axis) - primary plus secondary - (cm) TH1F *hzcoor = new TH1F("hzcoor","z Coordinate of the TOF Hit",800,-400.,400.); //---> Incidence Angle of the particle on the pad (or strip) (deg) - primary plus secondary - TH1F *hincangle = new TH1F("hincangle","Incidence Angle of the particle on the strip",90,0.,180.); printf ("Processing event %d \n", eventNumber); rl->GetEvent(eventNumber); // Get pointers to Alice detectors and Hits containers tofl->LoadHits(); TTree *TH = tofl->TreeH(); tof->SetTreeAddress(); if (!TH) { cout << "<TOFquickanal> No hit tree found" << endl; rc = 4; return rc; } // Import the Kine Tree for the event eventNumber in the file rl->LoadHeader(); rl->LoadKinematics(); //AliStack * stack = rl->Stack(); Int_t ntracks = TH->GetEntries(); cout<<" ntracks = "<<ntracks<<endl; AliTOFhitT0 *tofHit; // Start loop on tracks in the hits containers for (Int_t track=0; track<ntracks;track++) { tof->ResetHits(); TH->GetEvent(track); for(tofHit=(AliTOFhitT0*)tof->FirstHit(track); tofHit; tofHit=(AliTOFhitT0*)tof->NextHit()) { Float_t toflight = tofHit->GetTof(); toflight *= 1.E+09; // conversion from s to ns Double_t tofmom = tofHit->GetMom(); Int_t ipart = tofHit->Track(); TParticle *particle = gAlice->Particle(ipart); if (particle->GetFirstMother() < 0) { htofprim->Fill(toflight); htofmom->Fill(tofmom); } else { htofsec->Fill(toflight); } Double_t zcoor = tofHit->Z(); hzcoor->Fill(zcoor); Double_t incangle = tofHit->GetIncA(); hincangle->Fill(incangle); Double_t xcoor = particle->Vx(); Double_t ycoor = particle->Vy(); Double_t radius = TMath::Sqrt(xcoor*xcoor+ycoor*ycoor); if (particle->GetFirstMother() >= 0) hradius->Fill(radius); Double_t prodmom = particle->P(); if (prodmom!=0.) { Double_t dummy = (particle->Pz())/prodmom; Double_t prodthe = TMath::ACos(dummy); prodthe *= 57.29578; // conversion from rad to deg if (particle->GetFirstMother() < 0) hprodthe->Fill(prodthe); } // theta at production vertex if (particle->GetFirstMother() < 0) { hprodmom->Fill(prodmom); Double_t dummypx = particle->Px(); Double_t dummypy = particle->Py(); Double_t prodphi = TMath::ATan2(dummypy,dummypx); prodphi *= 57.29578; // conversion from rad to deg hprodphi->Fill(prodphi); } // phi at production vertex } // close loop on TOF-hits } // close loop on tracks in the hits containers //Create canvas, set the view range, show histograms TCanvas *c1 = new TCanvas("c1","Alice TOF hits quick analysis",400,10,600,700); c1->cd(); hprodmom->Draw(); TCanvas *c2 = new TCanvas("c2","Alice TOF hits quick analysis",400,10,600,700); c2->cd(); hprodthe->Draw(); TCanvas *c3 = new TCanvas("c3","Alice TOF hits quick analysis",400,10,600,700); c3->cd(); hprodphi->Draw(); TCanvas *c4 = new TCanvas("c4","Alice TOF hits quick analysis",400,10,600,700); c4->cd(); hzcoor->Draw(); TCanvas *c5 = new TCanvas("c5","Alice TOF hits quick analysis",400,10,600,700); c5->cd(); hradius->Draw(); TCanvas *c6 = new TCanvas("c6","Alice TOF hits quick analysis",400,10,600,700); c6->cd(); htofprim->Draw(); TCanvas *c7 = new TCanvas("c7","Alice TOF hits quick analysis",400,10,600,700); c7->cd(); htofsec->Draw(); TCanvas *c8 = new TCanvas("c8","Alice TOF hits quick analysis",400,10,600,700); c8->cd(); htofmom->Draw(); TCanvas *c9 = new TCanvas("c9","Alice TOF hits quick analysis",400,10,600,700); c9->cd(); hincangle->Draw(); //tofl->UnloadHits(); //rl->UnloadHeader(); //rl->UnloadgAlice(); //rl->UnloadKinematics(); return rc; }
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 Pythia8(const Int_t nEvents = 10) { gROOT->LoadMacro("TUtils.h"); if (LoadRootLibs()) return; if (LoadPythia8()) return; if (LoadThermalClass()) return; //============================================================================= TPythia8 *pythia8 = new TPythia8(); pythia8->ReadString("SoftQCD:all = on"); pythia8->ReadString("SoftQCD:singleDiffractive = on"); pythia8->ReadString("SoftQCD:doubleDiffractive = on"); pythia8->Initialize(2212, 2212, 14000.); //============================================================================= TGenThermalParticles *thermal = new TGenThermalParticles("Boltzmann"); thermal->SetMultiplicity(2000); thermal->SetMeanPt(0.7); thermal->SetPtRange(0.15, 200.); thermal->SetEtaRange(-0.8, 0.8); thermal->SetPhiRange(0., TMath::TwoPi()); //============================================================================= TClonesArray *particles = new TClonesArray("TParticle", 1000); for (Int_t iEvent=0; iEvent<nEvents; iEvent++) { pythia8->GenerateEvent(); if (iEvent==0) pythia8->EventListing(); pythia8->ImportParticles(particles, "Final"); Int_t nb = particles->GetEntriesFast(); cout << "iEvent = "<< iEvent << ", np before = " << nb; thermal->ImportParticles(particles, "Boltzmann"); Int_t na = particles->GetEntriesFast(); cout << ", np after = " << na << endl; TParticle *part = 0; for (Int_t i=0; i<na; i++) { part = (TParticle*)particles->At(i); if (!part) continue; Bool_t bThermalBkg = (part->GetStatusCode()==-1); if (!bThermalBkg) { Int_t kPDG = part->GetPdgCode(); Float_t dCharge = TDatabasePDG::Instance()->GetParticle(kPDG)->Charge(); } part = 0; } } //============================================================================= pythia8->PrintStatistics(); //============================================================================= return; }
//!PG main function int selector (TChain * tree, histos & plots, int if_signal) { plots.v_hardTAGPt = -99; plots.v_softTAGPt = -99; plots.v_TAGDProdEta = -99; plots.v_TAGDeta = -99; plots.v_TAGMinv = -99; plots.v_LepLep = -99; plots.v_hardLEPPt = -99; plots.v_softLEPPt = -99; plots.v_LEPDPhi = -99; plots.v_LEPDEta = -99; plots.v_LEPDR = -99; plots.v_LEPMinv = -99; plots.v_LEPProdCharge = -99; plots.v_hardLEPCharge = -99; plots.v_softLEPCharge = -99; plots.v_MET = -99; plots.v_ojets = -99 ; plots.v_ojetsCJV = -99 ; plots.v_ojetsRegionalCJV = -99 ; plots.v_ojetsZepp_01 = -99 ; plots.v_ojetsZepp_02 = -99 ; plots.v_ojetsZepp_03 = -99 ; plots.v_ojetsZepp_04 = -99 ; plots.v_ojetsZepp_05 = -99 ; plots.v_ojetsZepp_06 = -99 ; plots.v_ojetsZepp_07 = -99 ; plots.v_ojetsZepp_08 = -99 ; plots.v_ojetsZepp_09 = -99 ; plots.v_ojetsZepp_10 = -99 ; plots.v_ojetsZepp_11 = -99 ; plots.v_ojetsZepp_12 = -99 ; plots.v_ojetsZepp_13 = -99 ; plots.v_ojetsZepp_14 = -99 ; plots.v_decay_Channel_e = -99 ; plots.v_decay_Channel_mu = -99 ; plots.v_decay_Channel_tau = -99 ; TClonesArray * genParticles = new TClonesArray ("TParticle") ; tree->SetBranchAddress ("genParticles", &genParticles) ; // TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ; // tree->SetBranchAddress ("tagJets", &tagJets) ; TClonesArray * otherJets_temp = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress (g_KindOfJet.c_str(), &otherJets_temp) ; // tree->SetBranchAddress ("otherJets", &otherJets_temp) ; TClonesArray * electrons = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("electrons", &electrons) ; TClonesArray * muons = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("muons", &muons) ; TClonesArray * MET = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("MET", &MET) ; TClonesArray * tracks = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("tracks", &tracks) ; TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ; TClonesArray * otherJets = new TClonesArray ("TLorentzVector") ; int EleId[100]; float IsolEleSumPt_VBF[100]; int nEle; int EleCharge[30]; tree->SetBranchAddress ("nEle", &nEle) ; tree->SetBranchAddress ("EleId",EleId ) ; tree->SetBranchAddress ("IsolEleSumPt_VBF",IsolEleSumPt_VBF ) ; tree->SetBranchAddress ("EleCharge",EleCharge ) ; float IsolMuTr[100]; int nMu ; int MuCharge[30]; tree->SetBranchAddress ("nMu", &nMu) ; tree->SetBranchAddress ("IsolMuTr",IsolMuTr ) ; tree->SetBranchAddress ("MuCharge", MuCharge) ; int IdEvent; tree->SetBranchAddress ("IdEvent", &IdEvent) ; int nentries = (int) tree->GetEntries () ; plots.passedJetAndLepNumberSelections = 0; plots.analyzed = 0; plots.analyzed_ee = 0; plots.analyzed_mumu = 0; plots.analyzed_tautau = 0; plots.analyzed_emu = 0; plots.analyzed_etau = 0; plots.analyzed_mutau = 0; plots.passedJetAndLepNumberSelections_ee = 0; plots.passedJetAndLepNumberSelections_mumu = 0; plots.passedJetAndLepNumberSelections_tautau = 0; plots.passedJetAndLepNumberSelections_emu = 0; plots.passedJetAndLepNumberSelections_etau = 0; plots.passedJetAndLepNumberSelections_mutau = 0; //PG loop over the events for (int evt = 0 ; evt < nentries ; ++evt) { tree->GetEntry (evt) ; tagJets -> Clear () ; otherJets -> Clear () ; //---- check if signal ---- if (if_signal && (IdEvent!=123 && IdEvent!=124)) continue; plots.analyzed++; //!---- MC ---- if (IdEvent==123 || IdEvent==124) { //---- VBF event ---- plots.v_decay_Channel_e = 0; plots.v_decay_Channel_mu = 0; plots.v_decay_Channel_tau = 0; for (int iGen = 0; iGen < genParticles->GetEntries() ; ++iGen){ TParticle* myparticle = (TParticle*) genParticles->At(iGen); if (abs(myparticle->GetPdgCode()) == 24) { //---- W Int_t mother1 = 0; mother1 = myparticle->GetMother(0); if (mother1 == 25) { //---- mother is higgs ---- for (int iDaughter = 0; iDaughter<2; iDaughter++){ if (abs(myparticle->GetDaughter(iDaughter)) == 11) {//---- W -> e plots.v_decay_Channel_e++; } if (abs(myparticle->GetDaughter(iDaughter)) == 13) {//---- W -> mu plots.v_decay_Channel_mu++; } if (abs(myparticle->GetDaughter(iDaughter)) == 15) {//---- W -> tau plots.v_decay_Channel_tau++; } } } } } } if (plots.v_decay_Channel_e == 2) plots.analyzed_ee++; if (plots.v_decay_Channel_mu == 2) plots.analyzed_mumu++; if (plots.v_decay_Channel_tau == 2) plots.analyzed_tautau++; if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.analyzed_emu++; if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_etau++; if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_mutau++; int cutId = 0 ; plots.increase (cutId++) ; //AM 0 -> total number of events // std::cerr << "--- preambolo leptoni " << std::endl; std::vector<lepton> leptons ; //PG pour electrons into leptons collection //PG --------------------------------------- //PG loop over electrons for (int iele = 0; iele < electrons->GetEntries () ; ++iele) { TLorentzVector * theEle = (TLorentzVector*) (electrons->At (iele)) ; lepton dummy (theEle, 0, iele) ; leptons.push_back (dummy) ; } //PG loop over electrons //PG loop over muons for (int imu = 0 ; imu < nMu ; ++imu) { TLorentzVector * theMu = (TLorentzVector*) (muons->At (imu)) ; lepton dummy (theMu, 1, imu) ; leptons.push_back (dummy) ; } //PG loop over muons //PG this check is not necessary //PG if (leptons.size () < 2) continue ; // std::cerr << "--- inizia leptoni " << std::endl; //PG 2 LEPTONS //PG --------- /* applied after the leptons choice: in this case it is possible to differentiate the selections depending on the position of each lepton in the pt-sorting. the algorithm searches the first two most energetic candidates which satisfy the ID selections required for the first and second lepton respectively. Then check for channel analysis according to "g_LepLep" 0 == ee 1 == mumu 2 == emu 3 == mue pt ordered */ sort (leptons.rbegin (), leptons.rend (), lessThan ()) ; lepton primoLEP ; lepton secondoLEP ; double first_lepton_charge = 0; double second_lepton_charge = 0; int lepton_counter = 0; int electron_counter = 0; int muon_counter = 0; //PG find the first lepton int ilep = 0 ; for ( ; ilep < leptons.size () ; ++ilep) { if (leptons.at (ilep).m_flav == 0) //PG electron { //PG iso check bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] / leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento if (g_ISO1[0] == 1 && eleIso != 1) continue; //PG eleID check int eleID = EleId[leptons.at (ilep).m_index] ; if (g_ID1 == 100 && (eleID/100) != 1) continue; else if (g_ID1 == 10 && ((eleID%100)/10) != 1) continue; else if (g_ID1 == 1 && (eleID%10) != 1) continue; first_lepton_charge = EleCharge[leptons.at (ilep).m_index]; } else //PG muon { //PG iso check bool muIso = (IsolMuTr[leptons.at (ilep).m_index] / leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ; if (g_ISO1[1] == 1 && muIso != 1) continue; first_lepton_charge = MuCharge[leptons.at (ilep).m_index]; } primoLEP = leptons[ilep] ; lepton_counter++; if (leptons.at (ilep).m_flav == 0) electron_counter++; else muon_counter++; break ; } //PG find the first lepton //PG find the second lepton bool flag_secondoLEP = false; for (++ilep ; ilep < leptons.size () ; ++ilep) { if (leptons.at (ilep).m_flav == 0) //PG electron { //PG iso check bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] / leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento if (g_ISO2[0] == 1 && eleIso != 1) continue; //PG eleID check int eleID = EleId[leptons.at (ilep).m_index] ; if (g_ID2 == 100 && (eleID/100) != 1) continue; else if (g_ID2 == 10 && ((eleID%100)/10) != 1) continue; else if (g_ID2 == 1 && (eleID%10) != 1) continue; second_lepton_charge = EleCharge[leptons.at (ilep).m_index]; } else //PG muon { //PG iso check bool muIso = (IsolMuTr[leptons.at (ilep).m_index] / leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ; if (g_ISO2[1] == 1 && muIso != 1) continue; second_lepton_charge = MuCharge[leptons.at (ilep).m_index]; } if (!flag_secondoLEP) { secondoLEP = leptons[ilep] ; flag_secondoLEP = true; } if (leptons.at (ilep).m_kine->Pt () > 0) { if (leptons.at (ilep).m_flav == 0) electron_counter++; else muon_counter++; lepton_counter++; } } //PG find the second lepton //---- AM 3 --- 2 leptons after Id if (primoLEP.m_flav == -1 || secondoLEP.m_flav == -1) continue ; //---- AM 4 check for the two most transverse-energetic leptons have the right flavours plots.v_numLep = lepton_counter; plots.v_numEle = electron_counter; plots.v_numMu = muon_counter; if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 0) plots.v_LepLep = 0 ; if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 1) plots.v_LepLep = 1 ; if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 1) plots.v_LepLep = 2 ; if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 0) plots.v_LepLep = 3 ; plots.v_hardLEPPt = primoLEP.m_kine->Pt () ; //---- AM 5 pt_min of the most energetic lepton plots.v_softLEPPt = secondoLEP.m_kine->Pt () ; //---- AM 6 pt_min of the least energetic lepton plots.v_LEPDPhi = deltaPhi (primoLEP.m_kine->Phi (), secondoLEP.m_kine->Phi ()) ; //---- AM 7 Delta_phi_min between leptons plots.v_LEPDEta = deltaEta (primoLEP.m_kine->Eta (), secondoLEP.m_kine->Eta ()) ; plots.v_LEPDR = deltaR (primoLEP.m_kine->Phi (),primoLEP.m_kine->Eta (), secondoLEP.m_kine->Phi (), secondoLEP.m_kine->Eta ()) ; TLorentzVector sumLEP = *(primoLEP.m_kine) + *(secondoLEP.m_kine) ; plots.v_LEPMinv = sumLEP.M () ; //---- AM 9 MInv_min of leptons plots.v_LEPProdCharge = first_lepton_charge * second_lepton_charge ; plots.v_hardLEPCharge = first_lepton_charge ; plots.v_softLEPCharge = second_lepton_charge ; //PG MET //PG --- // std::cerr << "--- finito " << std::endl; TLorentzVector* met = ((TLorentzVector*) (MET->At(0))) ; //correct for muons for (int i = 0 ; i < nMu ; i++) { TLorentzVector * mu_v = (TLorentzVector*) (muons->At (i)) ; if (mu_v->Pt () > 3) { met->SetPx (met->Px () - mu_v->Px ()) ; met->SetPy (met->Py () - mu_v->Py ()) ; } } plots.v_MET = met->Pt () ; //---- AM 11 Met_min ----------------> Met correction ? // if (((TLorentzVector*) (MET->At (0)))->Pt () < g_METMin) continue ; plots.increase (cutId++) ; //PG 10 //PG Ztautau vetos //PG ------------- //PG the two electrons should not be opposite to each other // // TVector2 primoLEPT (primoLEP.m_kine->X (), primoLEP.m_kine->Y ()) ; // TVector2 secondoLEPT (secondoLEP.m_kine->X (), secondoLEP.m_kine->Y ()) ; // TVector2 METT (met->X (), met->Y ()) ; // // double Sum = METT * primoLEPT + METT * secondoLEPT / (1 + primoLEPT * secondoLEPT) ; // double Dif = METT * primoLEPT - METT * secondoLEPT / (1 - primoLEPT * secondoLEPT) ; // // TVector2 METT1 = 0.5 * (Sum + Dif) * primoLEPT ; // TVector2 METT2 = 0.5 * (Sum - Dif) * secondoLEPT ; // // double ptNu1 = METT1.Mod () / cos (primoLEP.m_kine->Theta ()) ; // double ptNu2 = METT2.Mod () / cos (secondoLEP.m_kine->Theta ()) ; plots.m_tree_selections->Fill(); plots.passedJetAndLepNumberSelections++; if (plots.v_decay_Channel_e == 2) plots.passedJetAndLepNumberSelections_ee++; if (plots.v_decay_Channel_mu == 2) plots.passedJetAndLepNumberSelections_mumu++; if (plots.v_decay_Channel_tau == 2) plots.passedJetAndLepNumberSelections_tautau++; if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.passedJetAndLepNumberSelections_emu++; if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_etau++; if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_mutau++; } //PG loop over the events plots.m_efficiency->Fill(); plots.m_efficiency->Write(); plots.m_tree_selections->Write(); delete otherJets_temp ; delete tagJets ; delete otherJets ; delete electrons ; delete muons ; delete MET ; delete tracks ; return 0; }
void pythia8_susy() { Int_t maxEvts = 100; // Maximo numero de eventos char* path = gSystem->ExpandPathName("$PYTHIA8DATA"); if (gSystem->AccessPathName(path)) { Warning("pythia8.C", "Environment variable PYTHIA8DATA must contain path to pythi8100/xmldoc directory !"); return; } // Load libraries gSystem->Load("$PYTHIA8/lib/libpythia8"); gSystem->Load("$PYTHIA8/lib/liblhapdfdummy"); gSystem->Load("libEG"); gSystem->Load("libEGPythia8"); //Definir archivo de salida TFile * outfile = new TFile("eventos_pythia8_SUSY.root","RECREATE"); // Array of particles TClonesArray* particles = new TClonesArray("TParticle", 5000); //Definir el TTree TTree*tree= new TTree("tree","Arbol con particulas segun Pythia8"); tree->Branch("particles",&particles); // Create pythia8 object TPythia8* pythia8 = new TPythia8(); //*Configurar: Aqui seleccione el proceso que quiere simular pythia8->ReadString("SUSY:all = on"); //Todos los procesos susy posibles //pythia8->ReadString("SUSY:qqbar2chi+-chi0 = on"); //Un proceso en especial //Importante: pasar a Pythia8 el nombre del archivo SLHA pythia8->ReadString("SLHA:file = SUSY_LM2_sftsht.slha"); //insertar aqui el nombre del archivo SLHA // Initialize pythia8->Initialize(2212 /* p */, 2212 /* p */, 7000. /* TeV */); int iev = 0; // Event loop while( iev < maxEvts ) { pythia8->GenerateEvent(); if (iev < 1) pythia8->EventListing(); pythia8->ImportParticles(particles,"All"); Int_t np = particles->GetEntriesFast(); // Particle loop for (Int_t ip = 0; ip < np; ip++) { TParticle* part = (TParticle*) particles->At(ip); Int_t ist = part->GetStatusCode(); Int_t pdg = part->GetPdgCode(); } tree->Fill(); ++iev; } pythia8->PrintStatistics(); outfile->Write(); outfile->Close(); }
void fastGenPA(Int_t nev = 1, char* filename = "gilc.root") { // Runloader IlcRunLoader* rl = IlcRunLoader::Open("gilc.root", "FASTRUN", "recreate"); rl->SetCompressionLevel(2); rl->SetNumberOfEventsPerFile(10000); rl->LoadKinematics("RECREATE"); rl->MakeTree("E"); gIlc->SetRunLoader(rl); // Create stack rl->MakeStack(); IlcStack* stack = rl->Stack(); // Header IlcHeader* header = rl->GetHeader(); // Create and Initialize Generator IlcGenerator *gener = CreateGenerator(); gener->Init(); gener->SetStack(stack); // // Event Loop // Int_t iev; for (iev = 0; iev < nev; iev++) { printf("\n \n Event number %d \n \n", iev); // Initialize event header->Reset(0,iev); rl->SetEventNumber(iev); stack->Reset(); rl->MakeTree("K"); // Generate event gener->Generate(); // Analysis Int_t npart = stack->GetNprimary(); printf("Analyse %d Particles\n", npart); for (Int_t part=0; part<npart; part++) { TParticle *MPart = stack->Particle(part); Int_t mpart = MPart->GetPdgCode(); } // Finish event header->SetNprimary(stack->GetNprimary()); header->SetNtrack(stack->GetNtrack()); // I/O // stack->FinishEvent(); header->SetStack(stack); rl->TreeE()->Fill(); rl->WriteKinematics("OVERWRITE"); } // event loop // // Termination // Generator gener->FinishRun(); // Write file rl->WriteHeader("OVERWRITE"); gener->Write(); rl->Write(); }
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]"); // }
void MatchComparison() { // // Initialize AliRun manager // // // Initialize run loader and load Kinematics // AliRunLoader *runLoader = AliRunLoader::Open("galice.root"); if (!runLoader) return; runLoader->LoadgAlice(); gAlice = runLoader->GetAliRun(); runLoader->LoadKinematics(); // // Initialize histograms with their error computation // TH1D *hgood = new TH1D("hgood", "Well matched tracks", 40, 0.0, 40.0); TH1D *hfake = new TH1D("hfake", "Fake matched tracks", 40, 0.0, 40.0); TH1D *htrue = new TH1D("htrue", "True matches" , 40, 0.0, 40.0); TH1D *hfound = new TH1D("hfound","Found matches" , 40, 0.0, 40.0); hgood->Sumw2(); hfake->Sumw2(); htrue->Sumw2(); hfound->Sumw2(); // // Open file containing true matches, // retrieve the Tree and link to a cursor. // TFile *fileTrue = TFile::Open("true-matches.root"); match_t trueMatch; // // Open file of found matches, // link the modified ESD container. // TFile *fileFound = TFile::Open("matchESD.root"); TTree *treeFound = (TTree*)fileFound->Get("esdTree"); AliESDEvent* esd = new AliESDEvent(); esd->ReadFromTree(treeFound); Long64_t nEvents = treeFound->GetEntries(); // // Loop on all events // Int_t im, it, ic, nTrueMatches, nTracks; Int_t label, trkLabel, cluLabel; for (Long64_t iev = 0; iev < nEvents; iev++) { // get true matches tree of given event TTree *treeTrue = (TTree*)fileTrue->Get(Form("tm_%d", iev)); treeTrue->SetBranchAddress("matches", &trueMatch); nTrueMatches = treeTrue->GetEntries(); // set TTree pointers to selected event runLoader->GetEvent(iev); treeFound->GetEntry(iev); AliStack *stack = runLoader->Stack(); nTracks = esd->GetNumberOfTracks(); // read all true pairs for (im = 0; im < nTrueMatches; im++) { treeTrue->GetEntry(im); AliESDtrack *track = esd->GetTrack(trueMatch.indexT); if (!track) continue; label = TMath::Abs(track->GetLabel()); TParticle *p = stack->Particle(label); htrue->Fill(p->Pt()); cout <<"filling true"<< endl; } // compare found matches for (Int_t it = 0; it < nTracks; it++) { AliESDtrack *track = esd->GetTrack(it); ic = track->GetEMCALcluster(); if (ic == AliEMCALTracker::kUnmatched) continue; ic = TMath::Abs(ic); AliESDCaloCluster *cl = esd->GetCaloCluster(ic); if (!cl) continue; if (!cl->IsEMCAL()) continue ; trkLabel = TMath::Abs(track->GetLabel()); cluLabel = cl->GetLabel(); if (trkLabel == cluLabel && trkLabel >= 0) { TParticle *p = stack->Particle(TMath::Abs(trkLabel)); hgood->Fill(p->Pt()); hfound->Fill(p->Pt()); cout <<"filling GOOD, pt:" << p->Pt()<< endl; } else { TParticle *p = stack->Particle(TMath::Abs(trkLabel)); hfake->Fill(p->Pt()); hfound->Fill(p->Pt()); cout <<"filling FAKE" << endl; } } } cout << "True matches : " << htrue->GetEntries() << endl; cout << "Found matches: " << hfound->GetEntries() << endl; cout << "Good matches : " << hgood->GetEntries() << endl; cout << "Fake matches : " << hfake->GetEntries() << endl; TFile *fout = TFile::Open("match-comparison.root", "RECREATE"); hgood->Write(); hfake->Write(); htrue->Write(); hfound->Write(); fout->Close(); }
void testsl() { gSystem->Load("libStarLight"); gSystem->Load("libAliStarLight"); TStarLight* sl = new TStarLight("starlight generator", "title", ""); sl->SetParameter("baseFileName = slight #suite of output files will be saved with this base name"); sl->SetParameter("BEAM_1_Z = 82 #Z of projectile"); sl->SetParameter("BEAM_1_A = 208 #A of projectile"); sl->SetParameter("BEAM_2_Z = 82 #Z of target"); sl->SetParameter("BEAM_2_A = 208 #A of target"); sl->SetParameter("BEAM_1_GAMMA = 1470.0 #Gamma of the colliding ion 1"); sl->SetParameter("BEAM_2_GAMMA = 1470.0 #Gamma of the colliding ion 2"); sl->SetParameter("W_MAX = -1 #Max value of w"); sl->SetParameter("W_MIN = -1 #Min value of w"); sl->SetParameter("W_N_BINS = 50 #Bins i w"); sl->SetParameter("RAP_MAX = 9. #max y"); sl->SetParameter("RAP_N_BINS = 200 #Bins i y"); sl->SetParameter("CUT_PT = 0 #Cut in pT? 0 = (no, 1 = yes)"); sl->SetParameter("PT_MIN = 1.0 #Minimum pT in GeV"); sl->SetParameter("PT_MAX = 3.0 #Maximum pT in GeV"); sl->SetParameter("CUT_ETA = 0 #Cut in pseudorapidity? (0 = no, 1 = yes)"); sl->SetParameter("ETA_MIN = -10 #Minimum pseudorapidity"); sl->SetParameter("ETA_MAX = 10 #Maximum pseudorapidity"); sl->SetParameter("PROD_MODE = 2 #gg or gP switch (1 = 2-photon, 2 = coherent vector meson (narrow), 3 = coherent vector meson (wide), 4 = incoherent vector meson)"); sl->SetParameter("N_EVENTS = 1000 #Number of events"); sl->SetParameter("PROD_PID = 443013 #Channel of interest; this is j/psi --> mu+ mu-"); sl->SetParameter("RND_SEED = 5574533 #Random number seed"); sl->SetParameter("BREAKUP_MODE = 5 #Controls the nuclear breakup; a 5 here makes no requirement on the breakup of the ions"); sl->SetParameter("INTERFERENCE = 0 #Interference (0 = off, 1 = on)"); sl->SetParameter("IF_STRENGTH = 1. #percent of intefernce (0.0 - 0.1)"); sl->SetParameter("INT_PT_MAX = 0.24 #Maximum pt considered, when interference is turned on"); sl->SetParameter("INT_PT_N_BINS =120 #Number of pt bins when interference is turned on"); sl->SetParameter("XSEC_METHOD = 1 # Set to 0 to use old method for calculating gamma-gamma luminosity"); sl->SetParameter("PYTHIA_FULL_EVENTRECORD = 0 # Write full pythia information to output (vertex, parents, daughter etc)."); sl->InitStarLight(); sl->PrintInputs(std::cout); TClonesArray tca("TParticle", 100); TLorentzVector v[2], vSum; TH1* hM = new TH1D("hM", "STARLIGHT;M#(){#pi^{+}#pi^{-}}", 200, 3.0, 3.2); TH1* hPt = new TH1D("hPt", "STARLIGHT;P_{T}#(){#pi^{+}#pi^{-}}", 80, 0., 2.); TH1* hY = new TH1D("hY", "STARLIGHT;Y#(){#pi^{+}#pi^{-}}", 100,-10., 10.); std::ofstream ofs("sl.txt"); TParticle *p; for (Int_t counter(0); counter<20000; ) { sl->GenerateEvent(); sl->BoostEvent(); sl->ImportParticles(&tca, "ALL"); Bool_t genOK = kTRUE; TLorentzVector vSum; for (Int_t i=0; i<tca.GetEntries() && genOK; ++i) { p = (TParticle*)tca.At(i); p->Momentum(v[i]); vSum += v[i]; // genOK = TMath::Abs(v[i].Rapidity()) <= 1.5; } tca.Clear(); if (!genOK) continue; Printf("%5d %d", counter, genOK); ++counter; vSum = v[0] + v[1]; ofs << std::fixed << std::setprecision(4) << vSum.M() << " " << vSum.Perp() << " " << vSum.Rapidity() << " " << v[0].Eta() << " " << v[0].Px() << " " << v[0].Py() << " " << v[0].Pz() << " " << v[1].Eta() << " " << v[1].Px() << " " << v[1].Py() << " " << v[1].Pz() << std::endl; hM->Fill(vSum.M()); hPt->Fill(vSum.Perp()); hY->Fill(vSum.Rapidity()); } TFile::Open("sl.root", "RECREATE"); sl->Write(); gFile->Write(); hM->Draw(); c1->SaveAs("SL.pdf("); hPt->Draw(); c1->SaveAs("SL.pdf"); hY->Draw(); c1->SaveAs("SL.pdf)"); }
//!PG main function int selector (TChain * tree, histos & plots, int if_signal) { plots.v_Jet_1_Pt = -99; plots.v_Jet_2_Pt = -99; plots.v_Jet_3_Pt = -99; plots.v_Jet_4_Pt = -99; plots.v_Jet_5_Pt = -99; plots.v_Jet_6_Pt = -99; plots.v_Jet_1_x = -99; plots.v_Jet_2_x = -99; plots.v_Jet_3_x = -99; plots.v_Jet_4_x = -99; plots.v_Jet_5_x = -99; plots.v_Jet_6_x = -99; plots.v_Jet_1_y = -99; plots.v_Jet_2_y = -99; plots.v_Jet_3_y = -99; plots.v_Jet_4_y = -99; plots.v_Jet_5_y = -99; plots.v_Jet_6_y = -99; plots.v_Jet_1_z = -99; plots.v_Jet_2_z = -99; plots.v_Jet_3_z = -99; plots.v_Jet_4_z = -99; plots.v_Jet_5_z = -99; plots.v_Jet_6_z = -99; plots.v_Jet_1_e = -99; plots.v_Jet_2_e = -99; plots.v_Jet_3_e = -99; plots.v_Jet_4_e = -99; plots.v_Jet_5_e = -99; plots.v_Jet_6_e = -99; plots.v_Jet_1_eta = -99; plots.v_Jet_2_eta = -99; plots.v_Jet_3_eta = -99; plots.v_Jet_4_eta = -99; plots.v_Jet_5_eta = -99; plots.v_Jet_6_eta = -99; plots.v_Jet_1_phi = -99; plots.v_Jet_2_phi = -99; plots.v_Jet_3_phi = -99; plots.v_Jet_4_phi = -99; plots.v_Jet_5_phi = -99; plots.v_Jet_6_phi = -99; plots.v_Jet_1_DR = -99; plots.v_Jet_2_DR = -99; plots.v_Jet_3_DR = -99; plots.v_Jet_4_DR = -99; plots.v_Jet_5_DR = -99; plots.v_Jet_6_DR = -99; plots.v_numEle = -99; plots.v_numMu = -99; plots.v_numJets = -99; plots.v_totNumJets = -99; // TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ; // tree->SetBranchAddress ("tagJets", &tagJets) ; TClonesArray * otherJets_temp = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress (g_KindOfJet.c_str(), &otherJets_temp) ; // tree->SetBranchAddress ("otherJets", &otherJets_temp) ; TClonesArray * electrons = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("electrons", &electrons) ; TClonesArray * muons = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("muons", &muons) ; TClonesArray * MET = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("MET", &MET) ; TClonesArray * tracks = new TClonesArray ("TLorentzVector") ; tree->SetBranchAddress ("tracks", &tracks) ; TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ; TClonesArray * otherJets = new TClonesArray ("TLorentzVector") ; TClonesArray * HiggsParticle = new TClonesArray ("TParticle") ; tree->SetBranchAddress ("HiggsParticle", &HiggsParticle) ; int EleId[100]; float IsolEleSumPt_VBF[100]; int nEle; tree->SetBranchAddress ("nEle", &nEle) ; tree->SetBranchAddress ("EleId",EleId ) ; tree->SetBranchAddress ("IsolEleSumPt_VBF",IsolEleSumPt_VBF ) ; float IsolMuTr[100]; int nMu ; tree->SetBranchAddress ("nMu", &nMu) ; tree->SetBranchAddress ("IsolMuTr",IsolMuTr ) ; int IdEvent; tree->SetBranchAddress ("IdEvent", &IdEvent) ; int nentries = (int) tree->GetEntries () ; plots.passedJetAndLepNumberSelections = 0; plots.analyzed = 0; //PG loop over the events // std::cerr << " --- nentries = " << nentries << std::endl; // nentries = std::min(10000,nentries); // nentries = 10000; if (g_numEvents!= -1) nentries = std::min(g_numEvents,nentries); std::cerr << " --- nentries = " << nentries << std::endl; for (int evt = 0 ; evt < nentries ; ++evt) { if (!(evt%1000)) std::cerr << " --- evt = " << evt << std::endl; plots.v_Jet_1_Pt = -99; plots.v_Jet_2_Pt = -99; plots.v_Jet_3_Pt = -99; plots.v_Jet_4_Pt = -99; plots.v_Jet_5_Pt = -99; plots.v_Jet_6_Pt = -99; plots.v_Jet_7_Pt = -99; plots.v_Jet_8_Pt = -99; plots.v_Jet_1_x = -99; plots.v_Jet_2_x = -99; plots.v_Jet_3_x = -99; plots.v_Jet_4_x = -99; plots.v_Jet_5_x = -99; plots.v_Jet_6_x = -99; plots.v_Jet_7_x = -99; plots.v_Jet_8_x = -99; plots.v_Jet_1_y = -99; plots.v_Jet_2_y = -99; plots.v_Jet_3_y = -99; plots.v_Jet_4_y = -99; plots.v_Jet_5_y = -99; plots.v_Jet_6_y = -99; plots.v_Jet_7_y = -99; plots.v_Jet_8_y = -99; plots.v_Jet_1_z = -99; plots.v_Jet_2_z = -99; plots.v_Jet_3_z = -99; plots.v_Jet_4_z = -99; plots.v_Jet_5_z = -99; plots.v_Jet_6_z = -99; plots.v_Jet_7_z = -99; plots.v_Jet_8_z = -99; plots.v_Jet_1_e = -99; plots.v_Jet_2_e = -99; plots.v_Jet_3_e = -99; plots.v_Jet_4_e = -99; plots.v_Jet_5_e = -99; plots.v_Jet_6_e = -99; plots.v_Jet_7_e = -99; plots.v_Jet_8_e = -99; plots.v_Jet_1_eta = -99; plots.v_Jet_2_eta = -99; plots.v_Jet_3_eta = -99; plots.v_Jet_4_eta = -99; plots.v_Jet_5_eta = -99; plots.v_Jet_6_eta = -99; plots.v_Jet_7_eta = -99; plots.v_Jet_8_eta = -99; plots.v_Jet_1_phi = -99; plots.v_Jet_2_phi = -99; plots.v_Jet_3_phi = -99; plots.v_Jet_4_phi = -99; plots.v_Jet_5_phi = -99; plots.v_Jet_6_phi = -99; plots.v_Jet_7_phi = -99; plots.v_Jet_8_phi = -99; plots.v_Jet_1_DR = -99; plots.v_Jet_2_DR = -99; plots.v_Jet_3_DR = -99; plots.v_Jet_4_DR = -99; plots.v_Jet_5_DR = -99; plots.v_Jet_6_DR = -99; plots.v_Jet_7_DR = -99; plots.v_Jet_8_DR = -99; plots.v_numEle = -99; plots.v_numMu = -99; plots.v_numJets = -99; plots.v_totNumJets = -99; tree->GetEntry (evt) ; tagJets -> Clear () ; otherJets -> Clear () ; //---- check if signal ---- if (if_signal && (IdEvent!=123 && IdEvent!=124)) continue; plots.analyzed++; //---- MC data ---- std::vector<TLorentzVector*> MCJets ; TLorentzVector* MCJets_temp[6] ; int counter = 0; if (if_signal && (IdEvent==123 || IdEvent==124)){ for(int ii=0; ii<9; ii++){ // if (ii==0 || ii==1){ // if (ii!=0 && ii!=1 && ii!=2 && ii!=3 && ii!=6){ if (ii!=2 && ii!=3 && ii!=6){ TParticle* myparticle = (TParticle*) HiggsParticle->At(ii); // std::cerr << "pdg = " << ii << " = " << myparticle->GetPdgCode() << std::endl; MCJets_temp[counter] = new TLorentzVector; myparticle->Momentum(*(MCJets_temp[counter])); MCJets.push_back((MCJets_temp[counter])); counter++; } } } //---- find Tagging Jets ---- double m_jetPtMin = 15.; double m_jetEtaMax = 5.; double m_jetDEtaMin = -1; double m_jetMjjMin = -1; std::vector<myJet> goodJets ; // std::cerr << std::endl << std::endl << std::endl << std::endl << std::endl; for (int l=0; l<otherJets_temp->GetEntries (); l++ ){ TLorentzVector* jet_temp = (TLorentzVector*) otherJets_temp->At(l); if (jet_temp->Pt()<m_jetPtMin) continue; //---- Eta max threshold ---- if (jet_temp->Eta()>m_jetEtaMax) continue; //---- pt min threshold ---- myJet dummy (jet_temp, 0, 0) ; goodJets.push_back (dummy) ; } // for (int gg=0; gg<goodJets.size(); gg++ ) std::cerr << " goodJets[" << gg << "] = " << &(goodJets.at(gg)) << std::endl; sort (goodJets.rbegin (), goodJets.rend (), lessThan ()) ; std::vector<std::pair<TLorentzVector*,TLorentzVector*> > Vect_PairQuark_RecoJet; std::vector<double> Map2D_PairQuark_RecoJet; int counter_map = 0; for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ---- for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ---- TLorentzVector* quark_temp = MCJets.at(k); TLorentzVector* jet_temp = goodJets.at(rr).m_kine; double DR = ROOT::Math::VectorUtil::DeltaR(quark_temp->BoostVector(),jet_temp->BoostVector()); Map2D_PairQuark_RecoJet.push_back(DR); counter_map++; } //--- end loop over recoJet ---- } //--- end loop over quarks ---- int selected_pair_jet[6] ; int selected_pair_quark[6] ; for (int jj=0; jj<MCJets.size(); jj++ ){ selected_pair_jet[jj] = -1; selected_pair_quark[jj] = -1; } for (int jj=0; jj<MCJets.size(); jj++ ){ double DR_min = 1000; counter_map = 0; int temp_selected_pair_jet = -1; int temp_selected_pair_quark = -1; for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ---- for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ---- bool already_done = false; for (int qq=0; qq<MCJets.size(); qq++) { if ((selected_pair_jet[qq] == rr) || (selected_pair_quark[qq] == k)) already_done = true; } if (!already_done){ double DR_temp = Map2D_PairQuark_RecoJet.at(counter_map); if (DR_temp<DR_min) { DR_min = DR_temp; temp_selected_pair_jet = rr; temp_selected_pair_quark = k; } } counter_map++; } } selected_pair_jet[jj] = temp_selected_pair_jet; selected_pair_quark[jj] = temp_selected_pair_quark; } for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ---- for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ---- bool used_one = false; for (int qq=0; qq<MCJets.size(); qq++) { if ((selected_pair_jet[qq] == rr) && (selected_pair_quark[qq] == k)) used_one = true; } if (used_one){ TLorentzVector* quark_temp = MCJets.at(k); TLorentzVector* jet_temp = goodJets.at(rr).m_kine; std::pair<TLorentzVector*,TLorentzVector*> PairQuark_RecoJet(quark_temp,jet_temp); Vect_PairQuark_RecoJet.push_back(PairQuark_RecoJet); } } //--- end loop over recoJet ---- } //--- end loop over quarks ---- for (int iJet=0; iJet<std::min(g_numJet,static_cast<int>(goodJets.size())); iJet++){ double minDR = -1000; double eta_reco_temp = goodJets.at (iJet).m_kine->Eta () ; double phi_reco_temp = goodJets.at (iJet).m_kine->Phi () ; for (int pp=0; pp<static_cast<int>(Vect_PairQuark_RecoJet.size()); pp++ ){ double eta_1 = Vect_PairQuark_RecoJet.at(pp).second->Eta(); double phi_1 = Vect_PairQuark_RecoJet.at(pp).second->Phi(); double DR_temp = deltaR(phi_1,eta_1,phi_reco_temp,eta_reco_temp); if (DR_temp<0.001) { double eta_2 = Vect_PairQuark_RecoJet.at(pp).first->Eta(); double phi_2 = Vect_PairQuark_RecoJet.at(pp).first->Phi(); minDR = deltaR(phi_1,eta_1,phi_2,eta_2); break; } } if (iJet==0) { plots.v_Jet_1_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_1_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_1_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_1_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_1_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_1_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_1_DR = minDR; } if (iJet==1) { plots.v_Jet_2_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_2_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_2_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_2_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_2_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_2_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_2_DR = minDR; } if (iJet==2) { plots.v_Jet_3_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_3_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_3_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_3_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_3_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_3_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_3_DR = minDR; } if (iJet==3) { plots.v_Jet_4_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_4_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_4_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_4_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_4_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_4_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_4_DR = minDR; } if (iJet==4) { plots.v_Jet_5_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_5_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_5_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_5_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_5_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_5_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_5_DR = minDR; } if (iJet==5) { plots.v_Jet_6_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_6_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_6_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_6_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_6_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_6_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_6_DR = minDR; } if (iJet==6) { plots.v_Jet_7_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_7_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_7_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_7_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_7_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_7_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_7_DR = minDR; } if (iJet==7) { plots.v_Jet_8_Pt = goodJets.at (iJet).m_kine->Pt () ; plots.v_Jet_8_x = goodJets.at (iJet).m_kine->X () ; plots.v_Jet_8_y = goodJets.at (iJet).m_kine->Y () ; plots.v_Jet_8_z = goodJets.at (iJet).m_kine->Z () ; plots.v_Jet_8_eta = goodJets.at (iJet).m_kine->Eta () ; plots.v_Jet_8_phi = goodJets.at (iJet).m_kine->Phi () ; plots.v_Jet_8_DR = minDR; } } int numJets = goodJets.size(); plots.v_numJets = numJets; plots.v_totNumJets = static_cast<double>(otherJets_temp->GetEntries ()); //---- leptons ---- plots.v_numEle = 0; plots.v_numMu = 0; std::vector<lepton> leptons ; //---- AM ---- loop over electrons for (int iele = 0; iele < electrons->GetEntries () ; ++iele) { TLorentzVector * theEle = (TLorentzVector*) (electrons->At (iele)) ; lepton dummy (theEle, 0, iele) ; leptons.push_back (dummy) ; } //---- AM ---- loop over muons for (int imu = 0 ; imu < nMu ; ++imu) { TLorentzVector * theMu = (TLorentzVector*) (muons->At (imu)) ; lepton dummy (theMu, 1, imu) ; leptons.push_back (dummy) ; } for (int ilep=0 ; ilep < leptons.size () ; ++ilep){ if (leptons.at (ilep).m_flav == 0) {//PG electron plots.v_numEle += 1; } if (leptons.at (ilep).m_flav == 1) {//PG muon plots.v_numMu += 1; } } plots.m_tree_selections->Fill(); if (numJets >=6 ) plots.passedJetAndLepNumberSelections++; for (int hh=0; hh<counter; hh++) delete MCJets_temp[hh]; } //PG loop over the events // std::cerr << "---- Finishes ----" << std::endl; g_OutputFile->cd(0); plots.m_efficiency->Fill(); plots.m_efficiency->Write(); plots.m_tree_selections->Write(); // std::cerr << "---- Written ----" << std::endl; delete otherJets_temp ; delete tagJets ; delete otherJets ; delete electrons ; delete muons ; delete MET ; delete tracks ; // std::cerr << "---- Deleted ----" << std::endl; return 0; }
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 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 amsvmc_MCStack::PushTrack(Int_t toBeDone, Int_t parent, Int_t pdg, Double_t px, Double_t py, Double_t pz, Double_t e, Double_t vx, Double_t vy, Double_t vz, Double_t tof, Double_t polx, Double_t poly, Double_t polz, TMCProcess mech, Int_t& ntr, Double_t weight, Int_t is) { // cout<<"DEBUG in amsvmc_MCStack::PushTrack, about to call"<<endl; /// Create a new particle and push into stack; /// adds it to the particles array (fParticles) and if not done to the /// stack (fStack). /// Use TParticle::fMother[1] to store Track ID. /// \param toBeDone 1 if particles should go to tracking, 0 otherwise /// \param parent number of the parent track, -1 if track is primary /// \param pdg PDG encoding /// \param px particle momentum - x component [GeV/c] /// \param py particle momentum - y component [GeV/c] /// \param pz particle momentum - z component [GeV/c] /// \param e total energy [GeV] /// \param vx position - x component [cm] /// \param vy position - y component [cm] /// \param vz position - z component [cm] /// \param tof time of flight [s] /// \param polx polarization - x component /// \param poly polarization - y component /// \param polz polarization - z component /// \param mech creator process VMC code /// \param ntr track number (is filled by the stack /// \param weight particle weight /// \param is generation status code const Int_t kFirstDaughter=-1; const Int_t kLastDaughter=-1; TClonesArray& particlesRef = *fParticles; Int_t trackId = GetNtrack(); TParticle* particle = new(particlesRef[trackId]) TParticle(pdg, is, parent, trackId, kFirstDaughter, kLastDaughter, px, py, pz, e, vx, vy, vz, tof); particle->SetPolarisation(polx, poly, polz); particle->SetWeight(weight); particle->SetUniqueID(mech); if (parent<0) fNPrimary++; if (toBeDone && pdg!=50000050) { // cout<<"DEBUG: a track is pushed into fStack, "<<pdg<<", stack number increased to"<<GetNtrack()<<endl; // printf("momemtum: px= %f, py= %f,pz= %f; position:x=%f, y=%f,z=%f; Total momemtum: %f \n",px,py,pz,vx,vy,vz,particle->P()); fStack.push(particle); } if (toBeDone && pdg==50000050 ) { float p=particle->P(); //pow(px*px+py*py+pz*pz,0.5); bool vmc_richpmtcut=RICHDB::detcer(p); // cout<<"vmc_richpmtcut"<<vmc_richpmtcut<<endl; if(vmc_richpmtcut){ // cout<<"DEBUG: a Cerenkov photon is produced, "<<pdg<<", P ="<<p<<endl; // cout<<"DEBUG: a Cerenkov photon is pushed into fStack, "<<pdg<<", stack number increased to"<<GetNtrack()<<endl; // printf("momemtum: px= %f, py= %f,pz= %f; position:x=%f, y=%f,z=%f; tof: %f \n",px*10000,py*10000,pz*10000,vx,vy,vz,tof); fStack.push(particle); } } ntr = GetNtrack() - 1; // cout<<"DEBUG: in PushTracks:"<<endl; // cout<<"parent = "<<parent<<endl; // cout<<"trackID:"<<trackId<<endl; // cout<<"ntr="<<ntr<<endl; // cout<<"Particle is : "<< pdg<<endl; }
void test(const char * sdir ="signal", const char * bdir ="backgr") { TStopwatch timer; timer.Start(); TString name; // Signal file, tree, and branch name = sdir; name += "/IlcESDs.root"; TFile * fSig = TFile::Open(name.Data()); TTree * tSig = (TTree*)fSig->Get("esdTree"); IlcESDEvent * esdSig = new IlcESDEvent();// The signal ESD object is put here esdSig->ReadFromTree(tSig); // Run loader (signal events) name = sdir; name += "/gilc.root"; IlcRunLoader* rlSig = IlcRunLoader::Open(name.Data()); // Run loader (underlying events) name = bdir; name += "/gilc.root"; IlcRunLoader* rlUnd = IlcRunLoader::Open(name.Data(),"Underlying"); // gIlc rlSig->LoadgIlc(); rlUnd->LoadgIlc(); gIlc = rlSig->GetIlcRun(); // Now load kinematics and event header rlSig->LoadKinematics(); rlSig->LoadHeader(); rlUnd->LoadKinematics(); rlUnd->LoadHeader(); // Loop on events: check that MC and data contain the same number of events Long64_t nevSig = rlSig->GetNumberOfEvents(); Long64_t nevUnd = rlUnd->GetNumberOfEvents(); Long64_t nSigPerUnd = nevSig/nevUnd; cout << nevSig << " signal events" << endl; cout << nevUnd << " underlying events" << endl; cout << nSigPerUnd << " signal events per one underlying" << endl; for (Int_t iev=0; iev<nevSig; iev++) { cout << "Signal event " << iev << endl; Int_t ievUnd = iev/nSigPerUnd; cout << "Underlying event " << ievUnd << endl; // Get signal ESD tSig->GetEntry(iev); // Get signal kinematics rlSig->GetEvent(iev); // Get underlying kinematics rlUnd->GetEvent(ievUnd); // Particle stack IlcStack * stackSig = rlSig->Stack(); Int_t nPartSig = stackSig->GetNtrack(); IlcStack * stackUnd = rlUnd->Stack(); Int_t nPartUnd = stackUnd->GetNtrack(); Int_t nrec = esdSig->GetNumberOfTracks(); cout << nrec << " reconstructed tracks" << endl; for(Int_t irec=0; irec<nrec; irec++) { IlcESDtrack * track = esdSig->GetTrack(irec); UInt_t label = TMath::Abs(track->GetTPCLabel()); if (label>=10000000) { // Underlying event. 10000000 is the // value of fkMASKSTEP in IlcRunDigitizer // cout << " Track from the underlying event" << endl; label %=10000000; if (label>=nPartUnd) continue; TParticle * part = stackUnd->Particle(label); if(part) part->Print(); } else { cout << " Track " << label << " from the signal event" << endl; if (label>=nPartSig) { cout <<"Strange, label outside the range "<< endl; continue; } TParticle * part = stackSig->Particle(label); if(part) part->Print(); } } } fSig->Close(); timer.Stop(); timer.Print(); }
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; }
void pythia8(Int_t nev = 100, Int_t ndeb = 1) { const char *p8dataenv = gSystem->Getenv("PYTHIA8DATA"); if (!p8dataenv) { const char *p8env = gSystem->Getenv("PYTHIA8"); if (!p8env) { Error("pythia8.C", "Environment variable PYTHIA8 must contain path to pythia directory!"); return; } TString p8d = p8env; p8d += "/xmldoc"; gSystem->Setenv("PYTHIA8DATA", p8d); } const char* path = gSystem->ExpandPathName("$PYTHIA8DATA"); if (gSystem->AccessPathName(path)) { Error("pythia8.C", "Environment variable PYTHIA8DATA must contain path to $PYTHIA8/xmldoc directory !"); return; } // Load libraries #ifndef G__WIN32 // Pythia8 is a static library on Windows if (gSystem->Getenv("PYTHIA8")) { gSystem->Load("$PYTHIA8/lib/libpythia8"); } else { gSystem->Load("libpythia8"); } #endif gSystem->Load("libEG"); gSystem->Load("libEGPythia8"); // Histograms TH1F* etaH = new TH1F("etaH", "Pseudorapidity", 120, -12., 12.); TH1F* ptH = new TH1F("ptH", "pt", 50, 0., 10.); // Array of particles TClonesArray* particles = new TClonesArray("TParticle", 1000); // Create pythia8 object TPythia8* pythia8 = new TPythia8(); // Configure pythia8->ReadString("HardQCD:all = on"); // Initialize pythia8->Initialize(2212 /* p */, 2212 /* p */, 14000. /* TeV */); // Event loop for (Int_t iev = 0; iev < nev; iev++) { pythia8->GenerateEvent(); if (iev < ndeb) pythia8->EventListing(); pythia8->ImportParticles(particles,"All"); Int_t np = particles->GetEntriesFast(); // Particle loop for (Int_t ip = 0; ip < np; ip++) { TParticle* part = (TParticle*) particles->At(ip); Int_t ist = part->GetStatusCode(); // Positive codes are final particles. if (ist <= 0) continue; Int_t pdg = part->GetPdgCode(); Float_t charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); if (charge == 0.) continue; Float_t eta = part->Eta(); Float_t pt = part->Pt(); etaH->Fill(eta); if (pt > 0.) ptH->Fill(pt, 1./(2. * pt)); } } pythia8->PrintStatistics(); TCanvas* c1 = new TCanvas("c1","Pythia8 test example",800,800); c1->Divide(1, 2); c1->cd(1); etaH->Scale(5./Float_t(nev)); etaH->Draw(); etaH->SetXTitle("#eta"); etaH->SetYTitle("dN/d#eta"); c1->cd(2); gPad->SetLogy(); ptH->Scale(5./Float_t(nev)); ptH->Draw(); ptH->SetXTitle("p_{t} [GeV/c]"); ptH->SetYTitle("dN/dp_{t}^{2} [GeV/c]^{-2}"); }
void fastGen(Int_t nev = 1, char* filename = "gilc.root") { IlcPDG::AddParticlesToPdgDataBase(); TDatabasePDG::Instance(); // Run loader IlcRunLoader* rl = IlcRunLoader::Open("gilc.root","FASTRUN","recreate"); rl->SetCompressionLevel(2); rl->SetNumberOfEventsPerFile(nev); rl->LoadKinematics("RECREATE"); rl->MakeTree("E"); gIlc->SetRunLoader(rl); // Create stack rl->MakeStack(); IlcStack* stack = rl->Stack(); // Header IlcHeader* header = rl->GetHeader(); // Create and Initialize Generator // Example of charm generation taken from Config_PythiaHeavyFlavours.C IlcGenPythia *gener = new IlcGenPythia(-1); gener->SetEnergyCMS(14000.); gener->SetMomentumRange(0,999999); gener->SetPhiRange(0., 360.); gener->SetThetaRange(0.,180.); // gener->SetProcess(kPyCharmppMNR); // Correct Pt distribution, wrong mult gener->SetProcess(kPyMb); // Correct multiplicity, wrong Pt gener->SetStrucFunc(kCTEQ4L); gener->SetPtHard(2.1,-1.0); gener->SetFeedDownHigherFamily(kFALSE); gener->SetStack(stack); gener->Init(); // Go to gilc.root rl->CdGAFile(); // Forbid some decays. Do it after gener->Init(0, because // the initialization of the generator includes reading of the decay table. IlcPythia * py= IlcPythia::Instance(); py->SetMDME(737,1,0); //forbid D*+->D+ + pi0 py->SetMDME(738,1,0);//forbid D*+->D+ + gamma // Forbid all D0 decays except D0->K- pi+ for(Int_t d=747; d<=762; d++){ py->SetMDME(d,1,0); } // decay 763 is D0->K- pi+ for(Int_t d=764; d<=807; d++){ py->SetMDME(d,1,0); } // // Event Loop // TStopwatch timer; timer.Start(); for (Int_t iev = 0; iev < nev; iev++) { cout <<"Event number "<< iev << endl; // Initialize event header->Reset(0,iev); rl->SetEventNumber(iev); stack->Reset(); rl->MakeTree("K"); // Generate event Int_t nprim = 0; Int_t ntrial = 0; Int_t ndstar = 0; //------------------------------------------------------------------------------------- while(!ndstar) { // Selection of events with D* stack->Reset(); stack->ConnectTree(rl->TreeK()); gener->Generate(); ntrial++; nprim = stack->GetNprimary(); for(Int_t ipart =0; ipart < nprim; ipart++){ TParticle * part = stack->Particle(ipart); if(part) { if (TMath::Abs(part->GetPdgCode())== 413) { TArrayI daughtersId; GetFinalDecayProducts(ipart,*stack,daughtersId); Bool_t kineOK = kTRUE; Double_t thetaMin = TMath::Pi()/4; Double_t thetaMax = 3*TMath::Pi()/4; for (Int_t id=1; id<=daughtersId[0]; id++) { TParticle * daughter = stack->Particle(daughtersId[id]); if (!daughter) { kineOK = kFALSE; break; } Double_t theta = daughter->Theta(); if (theta<thetaMin || theta>thetaMax) { kineOK = kFALSE; break; } } if (!kineOK) continue; part->Print(); ndstar++; } } } } cout << "Number of particles " << nprim << endl; cout << "Number of trials " << ntrial << endl; // Finish event header->SetNprimary(stack->GetNprimary()); header->SetNtrack(stack->GetNtrack()); // I/O stack->FinishEvent(); header->SetStack(stack); rl->TreeE()->Fill(); rl->WriteKinematics("OVERWRITE"); } // event loop timer.Stop(); timer.Print(); // Termination // Generator gener->FinishRun(); // Write file rl->WriteHeader("OVERWRITE"); gener->Write(); rl->Write(); }