From a6fbea2b29332d01531ed741f765b8131e275f9f Mon Sep 17 00:00:00 2001 From: schutz Date: Mon, 21 Apr 2008 13:04:06 +0000 Subject: [PATCH] more macros --- test/QA/CheckESD.C | 699 ++++++++++++++++++++++++++++++++++++++++++++ test/QA/DB.tgz | Bin 0 -> 12673 bytes test/QA/recqa.C | 3 +- test/QA/rootlogon.C | 12 + test/QA/simrun.C | 111 +++++++ test/QA/simrun.sh | 16 + test/QA/tag.C | 108 +++++++ 7 files changed, 947 insertions(+), 2 deletions(-) create mode 100644 test/QA/CheckESD.C create mode 100644 test/QA/DB.tgz create mode 100644 test/QA/rootlogon.C create mode 100644 test/QA/simrun.C create mode 100755 test/QA/simrun.sh create mode 100644 test/QA/tag.C diff --git a/test/QA/CheckESD.C b/test/QA/CheckESD.C new file mode 100644 index 00000000000..fe50acc13aa --- /dev/null +++ b/test/QA/CheckESD.C @@ -0,0 +1,699 @@ +#if !defined( __CINT__) || defined(__MAKECINT__) +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "AliRunLoader.h" +#include "AliLoader.h" +#include "AliESDEvent.h" +#include "AliRun.h" +#include "AliStack.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliPID.h" +#else +const Int_t kXiMinus = 3312; +const Int_t kOmegaMinus = 3334; +#endif + + +TH1F* CreateHisto(const char* name, const char* title, + Int_t nBins, Double_t xMin, Double_t xMax, + const char* xLabel = NULL, const char* yLabel = NULL) +{ +// create a histogram + + TH1F* result = new TH1F(name, title, nBins, xMin, xMax); + result->SetOption("E"); + if (xLabel) result->GetXaxis()->SetTitle(xLabel); + if (yLabel) result->GetYaxis()->SetTitle(yLabel); + result->SetMarkerStyle(kFullCircle); + return result; +} + +TH1F* CreateEffHisto(TH1F* hGen, TH1F* hRec) +{ +// create an efficiency histogram + + Int_t nBins = hGen->GetNbinsX(); + TH1F* hEff = (TH1F*) hGen->Clone("hEff"); + hEff->SetTitle(""); + hEff->SetStats(kFALSE); + hEff->SetMinimum(0.); + hEff->SetMaximum(110.); + hEff->GetYaxis()->SetTitle("#epsilon [%]"); + + for (Int_t iBin = 0; iBin <= nBins; iBin++) { + Double_t nGen = hGen->GetBinContent(iBin); + Double_t nRec = hRec->GetBinContent(iBin); + if (nGen > 0) { + Double_t eff = nRec/nGen; + hEff->SetBinContent(iBin, 100. * eff); + Double_t error = sqrt(eff*(1.-eff) / nGen); + if (error == 0) error = 0.0001; + hEff->SetBinError(iBin, 100. * error); + } else { + hEff->SetBinContent(iBin, -100.); + hEff->SetBinError(iBin, 0); + } + } + + return hEff; +} + +Bool_t FitHisto(TH1* histo, Double_t& res, Double_t& resError) +{ +// fit a gaussian to a histogram + + static TF1* fitFunc = new TF1("fitFunc", "gaus"); + fitFunc->SetLineWidth(2); + fitFunc->SetFillStyle(0); + Double_t maxFitRange = 2; + + if (histo->Integral() > 50) { + Float_t mean = histo->GetMean(); + Float_t rms = histo->GetRMS(); + fitFunc->SetRange(mean - maxFitRange*rms, mean + maxFitRange*rms); + fitFunc->SetParameters(mean, rms); + histo->Fit(fitFunc, "QRI0"); + histo->GetFunction("fitFunc")->ResetBit(1<<9); + res = TMath::Abs(fitFunc->GetParameter(2)); + resError = TMath::Abs(fitFunc->GetParError(2)); + return kTRUE; + } + + return kFALSE; +} + + +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[] = + {kElectron, kMuonMinus, kPiPlus, kKPlus, kProton}; + const char* partName[] = + {"electron", "muon", "pion", "kaon", "proton", "other"}; + Double_t partFrac[] = + {0.01, 0.01, 0.85, 0.10, 0.05}; + Int_t identified[6][5]; + for (Int_t iGen = 0; iGen < 6; iGen++) { + for (Int_t iRec = 0; iRec < 5; 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, 5, "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 = gAlice->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 + Double_t p[3]; + track->GetConstrainedPxPyPz(p); + TVector3 pTrack(p); + hResPtInv->Fill(100. * (1./pTrack.Pt() - 1./particle->Pt()) * + particle->Pt()); + hResPhi->Fill(1000. * (pTrack.Phi() - particle->Phi())); + hResTheta->Fill(1000. * (pTrack.Theta() - particle->Theta())); + + // PID + if ((track->GetStatus() & AliESDtrack::kESDpid) == 0) continue; + Int_t iGen = 5; + for (Int_t i = 0; i < 5; i++) { + if (TMath::Abs(particle->GetPdgCode()) == partCode[i]) iGen = i; + } + Double_t probability[5]; + track->GetESDpid(probability); + Double_t pMax = 0; + Int_t iRec = 0; + for (Int_t i = 0; i < 5; 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[5]; + track->GetIntegratedTimes(time); + if (iGen == iRec) { + hDEdxRight->Fill(pTrack.Mag(), track->GetTPCsignal()); + if ((track->GetStatus() & AliESDtrack::kTOFpid) != 0) { + hResTOFRight->Fill(track->GetTOFsignal() - time[iRec]); + } + } else { + hDEdxWrong->Fill(pTrack.Mag(), 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->GetEffMass()); + cascade->ChangeMassHypothesis(v0q,kOmegaMinus); + hMassOmega->Fill(cascade->GetEffMass()); + + 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 calorimeters clusters + { + Int_t nCaloCluster = esd->GetNumberOfCaloClusters(); + cout<<"CaloClusters "<GetCaloCluster(iCluster)->IsPHOS()) + hEPHOS->Fill(esd->GetCaloCluster(iCluster)->E()); + if(esd->GetCaloCluster(iCluster)->GetClusterType()==AliESDCaloCluster::kEMCALClusterv1) { + hEEMCAL->Fill(esd->GetCaloCluster(iCluster)->E()); + //cout<GetCaloCluster(iCluster)->E()< 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; +} diff --git a/test/QA/DB.tgz b/test/QA/DB.tgz new file mode 100644 index 0000000000000000000000000000000000000000..9dd31d4795f0d98c137d02aca885d5818e1cb4e0 GIT binary patch literal 12673 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 v12}*KIDi8SetDefaultStorage("alien://Folder=/alice/simulation/2007/PDC07_v4-09-Rev-00/Ideal/CDB/"); man->SetDefaultStorage("local://$ALICE_ROOT"); - //TString detectors("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO"); - TString detectors("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD PMD T0 VZERO"); + TString detectors("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO"); AliQA::SetQARefStorage(Form("%s%s/", AliQA::GetQARefDefaultStorage(), kYear)) ; AliQA::SetQARefDataDirName("Sim") ; //Data, Pedestals, BlackEvent, ..... diff --git a/test/QA/rootlogon.C b/test/QA/rootlogon.C new file mode 100644 index 00000000000..fae9b46a724 --- /dev/null +++ b/test/QA/rootlogon.C @@ -0,0 +1,12 @@ +{ + printf("\nWELCOME to ALICE QA\n\n"); + gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/TRD -I$ALICE_ROOT/RAW") ; + //load library neccesary for TPC alone +// gSystem->Load("$(ROOTSYS)/lib/libEG"); +// gSystem->Load("$(ROOTSYS)/lib/libGeom"); +// gSystem->Load("$(ROOTSYS)/lib/libVMC"); + //gSystem->Load("$(ALICE_ROOT)/lib/tgt_$(ALICE_TARGET)/libTRACKING"); + + +} + diff --git a/test/QA/simrun.C b/test/QA/simrun.C new file mode 100644 index 00000000000..6ad7853be29 --- /dev/null +++ b/test/QA/simrun.C @@ -0,0 +1,111 @@ +//#define VERBOSEARGS + +{ + // set job and simulation variables as : + // root run.C --run --event --process --minhard --maxhard --minpt + + int nrun = 0; + int nevent = 0; + int seed = 0; + + char sseed[1024]; + char srun[1024]; + char sevent[1024]; + char sprocess[1024]; + char sminpthard[1024]; + char smaxpthard[1024]; + char sminptgammapi0[1024]; + char squench[1024]; + char sqhat[1024]; + + sprintf(srun,""); + sprintf(sevent,""); + sprintf(sprocess,""); + sprintf(sminpthard,""); + sprintf(smaxpthard,""); + sprintf(sminptgammapi0,""); + sprintf(squench,""); + sprintf(sqhat,""); + + for (int i=0; i< gApplication->Argc();i++){ +#ifdef VERBOSEARGS + printf("Arg %d: %s\n",i,gApplication->Argv(i)); +#endif + if (!(strcmp(gApplication->Argv(i),"--run"))) + nrun = atoi(gApplication->Argv(i+1)); + sprintf(srun,"%d",nrun); + if (!(strcmp(gApplication->Argv(i),"--event"))) + nevent = atoi(gApplication->Argv(i+1)); + sprintf(sevent,"%d",nevent); + + if (!(strcmp(gApplication->Argv(i),"--process"))) + sprintf(sprocess, gApplication->Argv(i+1)); + + if (!(strcmp(gApplication->Argv(i),"--minhard"))) + sprintf(sminpthard,gApplication->Argv(i+1)); + + if (!(strcmp(gApplication->Argv(i),"--maxhard"))) + sprintf(smaxpthard,gApplication->Argv(i+1)); + + if (!(strcmp(gApplication->Argv(i),"--minpt"))) + sprintf(sminptgammapi0,gApplication->Argv(i+1)); + + if (!(strcmp(gApplication->Argv(i),"--quench"))) + sprintf(squench,gApplication->Argv(i+1)); + + if (!(strcmp(gApplication->Argv(i),"--qhat"))) + sprintf(sqhat,gApplication->Argv(i+1)); + + } + char cmd[200] ; + sprintf(cmd, ".! tar zxvf DB.tgz") ; + gROOT->ProcessLine(cmd) ; + + seed = nrun * 100000 + nevent; + sprintf(sseed,"%d",seed); + + if (seed==0) { + fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + fprintf(stderr,"!!!! WARNING! Seeding variable for MC is 0 !!!!\n"); + fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + } else { + fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + fprintf(stdout,"!!! MC Seed is %d \n",seed); + fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + } + + // set the seed environment variable + gSystem->Setenv("CONFIG_SEED",sseed); + gSystem->Setenv("DC_RUN",srun); + gSystem->Setenv("DC_EVENT",sevent); + gSystem->Setenv("DC_RUN_TYPE",sprocess);//"kPyGammaJetPHOS"); + gSystem->Setenv("PTHARDMIN",sminpthard);//"20"); + gSystem->Setenv("PTHARDMAX",smaxpthard);//"30"); + + gSystem->Setenv("PTGAMMAPI0MIN",sminptgammapi0);//"1"); + gSystem->Setenv("QUENCHING",squench); + gSystem->Setenv("QHAT",sqhat); + + + gSystem->Setenv("ECMS","14000"); + gSystem->Setenv("ALIMDC_RAWDB1","./mdc1"); + gSystem->Setenv("ALIMDC_RAWDB2","./mdc2"); + gSystem->Setenv("ALIMDC_TAGDB","./mdc1/tag"); + gSystem->Setenv("ALIMDC_RUNDB","./mdc1/meta"); + cout<< "SIMRUN:: Run " << gSystem->Getenv("DC_RUN") << " Event " << gSystem->Getenv("DC_EVENT") + << " Process " << gSystem->Getenv("DC_RUN_TYPE") + << " minpthard " << gSystem->Getenv("PTHARDMIN") + << " maxpthard " << gSystem->Getenv("PTHARDMAX") + << " minpt " << gSystem->Getenv("PTGAMMAPI0MIN") + << endl; + //gSystem->Exec("cp $ROOTSYS/etc/system.rootrc .rootrc"); + cout<<">>>>> SIMULATION <<<<<"<Exec("aliroot -b -q sim.C > sim.log 2>&1"); + cout<<">>>>> RECONSTRUCTION <<<<<"<Exec("aliroot -b -q rec.C > rec.log 2>&1"); + cout<<">>>>> TAG <<<<<"<Exec("aliroot -b -q tag.C > tag.log 2>&1"); + cout<<">>>>> CHECK ESD <<<<<"<Exec("aliroot -b -q CheckESD.C > check.log 2>&1"); + +} diff --git a/test/QA/simrun.sh b/test/QA/simrun.sh new file mode 100755 index 00000000000..f5ac7b11cb7 --- /dev/null +++ b/test/QA/simrun.sh @@ -0,0 +1,16 @@ +#!/bin/bash +cd $WORK/QATest +rm -f *.root *.C *.log +ln -si $ALICE_ROOT/test/QA/Config.C Config.C +aliroot -b -q $ALICE_ROOT/test/QA/sim.C > sim.log 2>&1 +alienroot -b -q $ALICE_ROOT/test/QA/simqa.C > simqa.log 2>&1 +aliroot -b -q $ALICE_ROOT/test/QA/rec.C > rec.log 2>&1 +alienroot -b -q $ALICE_ROOT/test/QA/recqa.C > recqa.log 2>&1 +alienroot -b -q $ALICE_ROOT/test/QA/tag.C > tag.log 2>&1 +cd $WORK/QATest/data +aliroot -b -q > rawqa.log 2>&1 << EOF +.x $ALICE_ROOT/test/QA/rootlogon.C +.L $ALICE_ROOT/test/QA/rawqa.C+ +rawqa(21950, 1) +EOF +exit \ No newline at end of file diff --git a/test/QA/tag.C b/test/QA/tag.C new file mode 100644 index 00000000000..749a8397de8 --- /dev/null +++ b/test/QA/tag.C @@ -0,0 +1,108 @@ +void tag() { + const char* turl = gSystem->Getenv("ALIEN_JDL_OUTPUTDIR"); + TString fESDFileName = "alien://"; + fESDFileName += turl; + fESDFileName += "/AliESDs.root"; + + TString fGUID = 0; + GetGUID(fGUID); + + TString fAliroot, fRoot, fGeant; + GetVersions(fAliroot,fRoot,fGeant); + + UpdateTag(fAliroot,fRoot,fGeant,fESDFileName,fGUID); +} + +//_____________________________________// +GetVersions(TString &fAliroot, TString &froot, TString &fgeant) { + const char* fver = gSystem->Getenv("ALIEN_JDL_PACKAGES"); + TString fS = fver; + Int_t fFirst = fS.First("#"); + + while(fFirst != -1) { + Int_t fTotalLength = fS.Length(); + TString tmp = fS; + TString fS1 = fS(0,fFirst); + tmp = fS(fFirst+2,fTotalLength); + fS = tmp; + + if(fS1.Contains("Root")) fAliroot = fS1; + if(fS1.Contains("ROOT")) froot = fS1; + if(fS1.Contains("GEANT")) fgeant = fS1; + + if(tmp.Contains("Root")) fAliroot = tmp; + if(tmp.Contains("ROOT")) froot = tmp; + if(tmp.Contains("GEANT")) fgeant = tmp; + + fFirst = tmp.First("#"); + } +} + +//_____________________________________// +GetGUID(TString &guid) { + ofstream myfile ("guid.txt"); + if (myfile.is_open()) { + TFile *f = TFile::Open("AliESDs.root","read"); + if(f->IsOpen()) { + guid = f->GetUUID().AsString(); + myfile << "AliESDs.root \t"<GetUUID().AsString(); + cout<OpenDirectory(gSystem->pwd()); + const char * name = 0x0; + // Add all files matching *pattern* to the chain + while((name = gSystem->GetDirEntry(dirp))) { + if (strstr(name,tagPattern)) { + TFile *f = TFile::Open(name,"read") ; + + AliRunTag *tag = new AliRunTag; + AliEventTag *evTag = new AliEventTag; + TTree *fTree = (TTree *)f->Get("T"); + fTree->SetBranchAddress("AliTAG",&tag); + + //Defining new tag objects + AliRunTag *newTag = new AliRunTag(); + TTree ttag("T","A Tree with event tags"); + TBranch * btag = ttag.Branch("AliTAG", &newTag); + btag->SetCompressionLevel(9); + for(Int_t iTagFiles = 0; iTagFiles < fTree->GetEntries(); iTagFiles++) { + fTree->GetEntry(iTagFiles); + newTag->SetRunId(tag->GetRunId()); + newTag->SetAlirootVersion(faliroot); + newTag->SetRootVersion(froot); + newTag->SetGeant3Version(fgeant); + const TClonesArray *tagList = tag->GetEventTags(); + for(Int_t j = 0; j < tagList->GetEntries(); j++) { + evTag = (AliEventTag *) tagList->At(j); + evTag->SetTURL(turl); + evTag->SetGUID(guid); + newTag->AddEventTag(*evTag); + } + ttag.Fill(); + newTag->Clear(); + }//tag file loop + + TFile* ftag = TFile::Open(name, "recreate"); + ftag->cd(); + ttag.Write(); + ftag->Close(); + + delete tag; + delete newTag; + }//pattern check + }//directory loop + return kTRUE; +} -- 2.31.1