TH1F *
CheckEnabledChannels(Int_t run, Bool_t checkROEff = kTRUE, const Char_t *dbString = "raw://")
{
/* init */
AliCDBManager *cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(dbString);
cdb->SetRun(run);
AliTOFcalib calib;
calib.Init();
TH2F *hEnabledMap = new TH2F("hEnabledMap", "Enabled channel map;sector;strip", 72, 0., 18., 91, 0., 91.);
TH1F *hEnabledFlag = new TH1F("hEnabledFlag", "Enabled channel flag;index;flag", 157248, 0., 157248.);
AliTOFcalibHisto calibhisto;
calibhisto.LoadCalibHisto();
calibhisto.LoadCalibStat(); /* temp */
Int_t sector, sectorStrip, padx, fea;
Float_t hitmapx, hitmapy;
/* loop over channels */
for (Int_t ich = 0; ich < 157248; ich++) {
if (!calib.IsChannelEnabled(ich, checkROEff)) continue;
sector = calibhisto.GetCalibMap(AliTOFcalibHisto::kSector, ich);
sectorStrip = calibhisto.GetCalibMap(AliTOFcalibHisto::kSectorStrip, ich);
padx = calibhisto.GetCalibMap(AliTOFcalibHisto::kPadX, ich);
fea = padx / 12;
hitmapx = sector + ((Double_t)(3 - fea) + 0.5) / 4.;
hitmapy = sectorStrip;
hEnabledMap->Fill(hitmapx, hitmapy);
hEnabledFlag->SetBinContent(ich + 1, 1);
}
hEnabledMap->DrawCopy("colz");
return hEnabledFlag;
}
exampleScript()
{
gSystem->CompileMacro("betaHelperFunctions.h" ,"kO") ;
gSystem->CompileMacro("RooNormalFromFlatPdf.cxx" ,"kO") ;
gSystem->CompileMacro("RooBetaInverseCDF.cxx" ,"kO") ;
gSystem->CompileMacro("RooBetaPrimeInverseCDF.cxx" ,"kO") ;
gSystem->CompileMacro("RooCorrelatedBetaGeneratorHelper.cxx" ,"kO") ;
gSystem->CompileMacro("RooCorrelatedBetaPrimeGeneratorHelper.cxx" ,"kO") ;
gSystem->CompileMacro("rooFitBetaHelperFunctions.h","kO") ;
TFile betaTest("betaTest.root","RECREATE");
betaTest.cd();
RooWorkspace workspace("workspace");
TString correlatedName("testVariable");
TString observables("observables");
TString nuisances("nuisances");
RooAbsArg* betaOne = getCorrelatedBetaConstraint(workspace,"betaOne","",
0.5 , 0.1 ,
observables, nuisances,
correlatedName );
printf("\n\n *** constraint name is %s from betaOne and %s\n\n", betaOne->GetName(), correlatedName.Data() ) ;
RooAbsArg* betaTwo = getCorrelatedBetaConstraint(workspace,"betaTwo","",
0 , 0 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaThree = getCorrelatedBetaConstraint(workspace,"betaThree","",
0.2 , 0.01 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaFour = getCorrelatedBetaConstraint(workspace,"betaFour","",
0.7 , 0.1 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaFourC = getCorrelatedBetaConstraint(workspace,"betaFourC","",
0.7 , 0.1 ,
observables, nuisances,
correlatedName, kTRUE );
RooAbsArg* betaPrimeOne = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOne","",
1.0 , 0.5 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeOneC = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOneC","",
1.0 , 0.5 ,
observables, nuisances,
correlatedName, kTRUE );
RooAbsArg* betaPrimeTwo = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeTwo","",
0.7 , 0.5 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeThree = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeThree","",
0.1 , 0.05 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeFour = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeFour","",
7 , 1 ,
observables, nuisances,
correlatedName );
RooRealVar* correlatedParameter = workspace.var(correlatedName);
RooAbsPdf* normalFromFlat = workspace.pdf(correlatedName+"_Constraint");
RooDataSet* data = normalFromFlat->generate(RooArgSet(*correlatedParameter),1e5);
data->addColumn(*normalFromFlat);
data->addColumn(*betaOne);
data->addColumn(*betaTwo);
data->addColumn(*betaThree);
data->addColumn(*betaFour);
data->addColumn(*betaFourC);
data->addColumn(*betaPrimeOne);
data->addColumn(*betaPrimeTwo);
data->addColumn(*betaPrimeThree);
data->addColumn(*betaPrimeFour);
data->addColumn(*betaPrimeOneC);
data->Print("v");
workspace.Print() ;
//Setup Plotting Kluges:
RooRealVar normalPlotter (correlatedName+"_Constraint" , correlatedName+"_Constraint" ,0,1);
RooPlot* normalPlot = normalPlotter.frame();
data->plotOn(normalPlot);
RooRealVar betaOnePlotter ("betaOne_BetaInverseCDF" ,"betaOne_BetaInverseCDF" ,0,1);
RooRealVar betaTwoPlotter ("betaTwo_BetaInverseCDF" ,"betaTwo_BetaInverseCDF" ,0,1);
RooRealVar betaThreePlotter("betaThree_BetaInverseCDF","betaThree_BetaInverseCDF",0,1);
RooRealVar betaFourPlotter ("betaFour_BetaInverseCDF" ,"betaFour_BetaInverseCDF" ,0,1);
RooRealVar betaFourCPlotter ("betaFourC_BetaInverseCDF" ,"betaFourC_BetaInverseCDF" ,0,1);
RooRealVar betaPrimeOnePlotter ("betaPrimeOne_BetaPrimeInverseCDF" ,"betaPrimeOne_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeOneCPlotter ("betaPrimeOneC_BetaPrimeInverseCDF" ,"betaPrimeOneC_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeTwoPlotter ("betaPrimeTwo_BetaPrimeInverseCDF" ,"betaPrimeTwo_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeThreePlotter("betaPrimeThree_BetaPrimeInverseCDF","betaPrimeThree_BetaPrimeInverseCDF",0,0.3);
RooRealVar betaPrimeFourPlotter ("betaPrimeFour_BetaPrimeInverseCDF" ,"betaPrimeFour_BetaPrimeInverseCDF" ,4,12);
RooPlot* betaOnePlot = betaOnePlotter .frame();
RooPlot* betaTwoPlot = betaTwoPlotter .frame();
RooPlot* betaThreePlot = betaThreePlotter.frame();
RooPlot* betaFourPlot = betaFourPlotter .frame();
RooPlot* betaFourCPlot = betaFourCPlotter .frame();
data->plotOn(betaOnePlot );
data->plotOn(betaTwoPlot );
data->plotOn(betaThreePlot);
data->plotOn(betaFourPlot );
data->plotOn(betaFourCPlot );
RooPlot* betaPrimeOnePlot = betaPrimeOnePlotter .frame();
RooPlot* betaPrimeOneCPlot = betaPrimeOneCPlotter .frame();
RooPlot* betaPrimeTwoPlot = betaPrimeTwoPlotter .frame();
RooPlot* betaPrimeThreePlot = betaPrimeThreePlotter.frame();
RooPlot* betaPrimeFourPlot = betaPrimeFourPlotter .frame();
data->plotOn(betaPrimeOnePlot );
data->plotOn(betaPrimeOneCPlot );
data->plotOn(betaPrimeTwoPlot );
data->plotOn(betaPrimeThreePlot);
data->plotOn(betaPrimeFourPlot );
TCanvas* underlyingVariable = new TCanvas("underlyingVariable","underlyingVariable",800,800);
underlyingVariable->Divide(2,2);
underlyingVariable->cd(1);
RooPlot* underlyingPlot = correlatedParameter->frame();
data->plotOn(underlyingPlot);
underlyingPlot->Draw();
underlyingVariable->cd(2);
normalPlot->Draw();
underlyingVariable->cd(3);
TH2F* underlying = data->createHistogram(*correlatedParameter,normalPlotter,50,50);
underlying->Draw("col");
TH2F* legoUnderlying = (TH2F*)underlying->Clone();
underlyingVariable->cd(4);
legoUnderlying->Draw("lego");
underlyingVariable->SaveAs("underlyingVariable.pdf");
TCanvas* betaCanvas = new TCanvas("betaCanvas","betaCanvas",800,800);
betaCanvas->Divide(3,2);
betaCanvas->cd(1);
betaOnePlot->Draw();
betaCanvas->cd(2);
betaTwoPlot->Draw();
betaCanvas->cd(3);
betaThreePlot->Draw();
betaCanvas->cd(4);
betaFourPlot->Draw();
betaCanvas->cd(5);
betaFourCPlot->Draw();
betaCanvas->SaveAs("betaVariables.pdf");
TCanvas* betaPrimeCanvas = new TCanvas("betaPrimeCanvas","betaPrimeCanvas",1200,800);
betaPrimeCanvas->Divide(3,2);
betaPrimeCanvas->cd(1);
betaPrimeOnePlot->Draw();
betaPrimeCanvas->cd(2);
betaPrimeTwoPlot->Draw();
betaPrimeCanvas->cd(3);
betaPrimeThreePlot->Draw();
betaPrimeCanvas->cd(4);
betaPrimeFourPlot->Draw();
betaPrimeCanvas->cd(5);
betaPrimeOneCPlot->Draw();
betaPrimeCanvas->SaveAs("betaPrimeVariables.pdf");
TCanvas* betaCorrelationsCanvas = new TCanvas("betaCorrelationsCanvas","betaCorrelationsCanvas",1600,800);
betaCorrelationsCanvas->Divide(4,2);
TH2F* oneTwo = data->createHistogram(betaOnePlotter,betaTwoPlotter,30,30);
TH2F* oneThree = data->createHistogram(betaOnePlotter,betaThreePlotter,30,30);
TH2F* oneFour = data->createHistogram(betaOnePlotter,betaFourPlotter,30,30);
TH2F* twoThree = data->createHistogram(betaTwoPlotter,betaThreePlotter,30,30);
TH2F* twoFour = data->createHistogram(betaTwoPlotter,betaFourPlotter,30,30);
TH2F* threeFour = data->createHistogram(betaThreePlotter,betaFourPlotter,30,30);
TH2F* twoFourC = data->createHistogram(betaTwoPlotter,betaFourCPlotter,30,30);
TH2F* fourFourC = data->createHistogram(betaFourPlotter,betaFourCPlotter,30,30);
betaCorrelationsCanvas->cd(1);
oneTwo->DrawCopy("lego");
betaCorrelationsCanvas->cd(2);
oneThree->DrawCopy("lego");
betaCorrelationsCanvas->cd(3);
oneFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(4);
twoThree->DrawCopy("lego");
betaCorrelationsCanvas->cd(5);
twoFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(6);
threeFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(7);
twoFourC->DrawCopy("lego");
betaCorrelationsCanvas->cd(8);
fourFourC->DrawCopy("lego");
betaCorrelationsCanvas->SaveAs("betaCorrelations.pdf");
TCanvas* betaPrimeCorrelationsCanvas = new TCanvas("betaPrimeCorrelationsCanvas","betaPrimeCorrelationsCanvas",1600,800);
betaPrimeCorrelationsCanvas->Divide(4,2);
TH2F* oneTwo = data->createHistogram(betaPrimeOnePlotter,betaPrimeTwoPlotter,30,30);
TH2F* oneThree = data->createHistogram(betaPrimeOnePlotter,betaPrimeThreePlotter,30,30);
TH2F* oneFour = data->createHistogram(betaPrimeOnePlotter,betaPrimeFourPlotter,30,30);
TH2F* twoThree = data->createHistogram(betaPrimeTwoPlotter,betaPrimeThreePlotter,30,30);
TH2F* twoFour = data->createHistogram(betaPrimeTwoPlotter,betaPrimeFourPlotter,30,30);
TH2F* threeFour = data->createHistogram(betaPrimeThreePlotter,betaPrimeFourPlotter,30,30);
TH2F* oneOneC = data->createHistogram(betaPrimeOnePlotter,betaPrimeOneCPlotter,30,30);
betaPrimeCorrelationsCanvas->cd(1);
oneTwo->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(2);
oneThree->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(3);
oneFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(4);
twoThree->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(5);
twoFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(6);
threeFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(7);
oneOneC->DrawCopy("lego");
betaPrimeCorrelationsCanvas->SaveAs("betaPrimeCorrelations.pdf");
RooProdPdf totalPdf("totalPdf","totalPdf",workspace.allPdfs());
totalPdf.Print("v");
RooArgSet* observableSet = workspace.set("observables");
observableSet->Print();
RooDataSet* allDataOne = totalPdf.generate(*observableSet,1);
allDataOne->Print("v");
correlatedParameter->setVal(0.25);
RooDataSet* allDataTwo = totalPdf.generate(*observableSet,1);
allDataTwo->Print("v");
correlatedParameter->setVal(0.75);
RooDataSet* allDataThree = totalPdf.generate(*observableSet,1);
allDataThree->Print("v");
//Testing for extreme values!
for(int i = 0; i< 101; i++)
{
correlatedParameter->setVal((double)i/100.);
cout << "Correlation parameter has value of " << correlatedParameter->getVal();
cout << " and the pdf has an unnormalized value of " << normalFromFlat->getVal() << endl;
}
}
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 display(){
gROOT->ProcessLine(".x lhcbStyle.C");
gStyle->SetPalette(1);
string filename = "../analysed/SET9THL914.root";
TFile* file = new TFile(filename.c_str(),"OPEN");
int nBinsX=32; int nBinsY=32;
int nPixelsX=64; int nPixelsY=64;
std::cout<<"Making global intercept tot map"<<std::endl;
// Global intercept map (not per pixel)
TH2F* hToTMap = new TH2F("hToTMap","hToTMap",nBinsX,0,nPixelsX,nBinsY,0,nPixelsY);
for(int x=0;x<nBinsX;x++){
for(int y=0;y<nBinsY;y++){
int id = x + y*nBinsX;
// Get the ToT distribution for this location
string histoname = "/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixMap"+makestring(id);
TH1F* totMapHisto = 0;
totMapHisto = (TH1F*)gDirectory->Get(histoname.c_str());
if(totMapHisto == 0) continue;
if(totMapHisto->GetEntries() < 20) continue;
// Fit the tot distribution and enter the value in the ToT map
totMapHisto->Fit("gaus","0q");
TF1* fit = totMapHisto->GetFunction("gaus");
hToTMap->Fill(x*floor(nPixelsX/nBinsX),y*floor(nPixelsY/nBinsY),fit->GetParameter(1));
delete fit; delete totMapHisto;
}
}
// Plot the map of ToT
TCanvas* canv = new TCanvas();
hToTMap->GetXaxis()->SetTitle("Column");
hToTMap->GetYaxis()->SetTitle("Row");
hToTMap->GetZaxis()->SetTitle("Mean charge (ToT)");
hToTMap->SetMaximum(9);
hToTMap->SetMinimum(5);
hToTMap->DrawCopy("colz");
std::cout<<"Making per pixel tot map"<<std::endl;
// Per pixel map
TH2F* hToTMapPerPixel = new TH2F("hToTMapPerPixel","hToTMapPerPixel",nPixelsX,0,nPixelsX,nPixelsY,0,nPixelsY);
for(int x=0;x<nPixelsX;x++){
for(int y=0;y<nPixelsY;y++){
int id = x + y*nPixelsX;
// Get the ToT distribution for this location
string histoname = "/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixPixel"+makestring(id);
TH1F* totMapHisto = 0;
totMapHisto = (TH1F*)gDirectory->Get(histoname.c_str());
if(totMapHisto == 0) continue;
if(totMapHisto->GetEntries() < 10) continue;
// Fit the tot distribution and enter the value in the ToT map
totMapHisto->Fit("gaus","0q");
TF1* fit = totMapHisto->GetFunction("gaus");
hToTMapPerPixel->Fill(x,y,fit->GetParameter(1));
delete fit; delete totMapHisto;
}
}
// Plot the map of ToT
TCanvas* canv2 = new TCanvas();
hToTMapPerPixel->GetXaxis()->SetTitle("Column");
hToTMapPerPixel->GetYaxis()->SetTitle("Row");
hToTMapPerPixel->GetZaxis()->SetTitle("Mean charge (ToT)");
hToTMapPerPixel->SetMaximum(10);
hToTMapPerPixel->SetMinimum(0);
hToTMapPerPixel->DrawCopy("colz");
std::cout<<"Making pixel response tot maps"<<std::endl;
// Pixel response maps
int responseBins=100;
double responseWidth=0.05;
TH2F* hToTMapPixelResponseX = new TH2F("hToTMapPixelResponseX","hToTMapPixelResponseX",responseBins+1,-responseWidth,responseWidth,15,0,15);
for(double rID=0;rID<responseBins;rID++){
// Get the ToT distribution for this location
string histoname = "/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixResponseX"+makestringD(rID);
TH1F* totMapHisto = 0;
totMapHisto = (TH1F*)gDirectory->Get(histoname.c_str());
if(totMapHisto == 0) continue;
if(totMapHisto->GetEntries() < 1) continue;
// loop over all tot bins
for(int i=0;i<45;i++){
hToTMapPixelResponseX->Fill(2.*responseWidth*(rID/100.)-responseWidth,i,totMapHisto->GetBinContent(totMapHisto->FindBin(i)));
}
delete totMapHisto;
}
// Plot the map of ToT
TCanvas* canv3 = new TCanvas();
hToTMapPixelResponseX->GetXaxis()->SetTitle("Track distance x (mm)");
hToTMapPixelResponseX->GetYaxis()->SetTitle("ToT");
hToTMapPixelResponseX->DrawCopy("colz");
TH1F* hToTProfilePixelResponseY = new TH1F("hToTProfilePixelResponseY","hToTProfilePixelResponseY",responseBins+1,-responseWidth,responseWidth);
TH2F* hToTMapPixelResponseY = new TH2F("hToTMapPixelResponseY","hToTMapPixelResponseY",responseBins+1,-responseWidth,responseWidth,16,0,16);
for(double rID=0;rID<responseBins;rID++){
// Get the ToT distribution for this location
string histoname = "/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixResponseY"+makestringD(rID);
TH1F* totMapHisto = 0;
totMapHisto = (TH1F*)gDirectory->Get(histoname.c_str());
if(totMapHisto == 0) continue;
if(totMapHisto->GetEntries() < 1) continue;
// loop over all tot bins
for(int i=0;i<45;i++){
hToTMapPixelResponseY->Fill(2.*responseWidth*(rID/100.)-responseWidth,i,totMapHisto->GetBinContent(totMapHisto->FindBin(i)));
}
hToTProfilePixelResponseY->Fill(2.*responseWidth*(rID/100.)-responseWidth+0.001,totMapHisto->GetXaxis()->GetBinCenter(totMapHisto->GetMaximumBin()));
delete totMapHisto;
}
// Plot the map of ToT
TCanvas* canv4 = new TCanvas();
hToTMapPixelResponseY->GetXaxis()->SetTitle("Track distance y (mm)");
hToTMapPixelResponseY->GetYaxis()->SetTitle("ToT");
hToTMapPixelResponseY->GetZaxis()->SetTitle("Number of events");
hToTMapPixelResponseY->DrawCopy("colz");
// drawline(-0.03,1,7);
// drawline(0.03,1,7);
TCanvas* canv6 = new TCanvas();
hToTProfilePixelResponseY->GetXaxis()->SetTitle("Track distance y (mm)");
hToTProfilePixelResponseY->GetYaxis()->SetTitle("Most probable ToT");
hToTProfilePixelResponseY->DrawCopy("");
TCanvas* canv5 = new TCanvas();
TH1F* sidebandLow = (TH1F*)gDirectory->Get("/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixResponseY20");
TH1F* sidebandHigh = (TH1F*)gDirectory->Get("/tpanal/ClicpixAnalysis/hClusterTOTAssociated1pixResponseY80");
sidebandHigh->GetXaxis()->SetTitle("ToT (single pixel)");
sidebandHigh->GetXaxis()->SetRangeUser(0,20);
sidebandHigh->DrawCopy("");
sidebandLow->SetLineColor(2);
sidebandLow->DrawCopy("same");
}
void RawHitMapMaker::end()
{
if (!display || !parameters->verbose) return;
// HITMAP CANVAS
TCanvas* cHM = new TCanvas("cHM", "Raw hitmaps", 720, 720);
cHM->cd();
cHM->Divide(3, 3);
for (int i = 0; i < summary->nDetectors(); ++i) {
if (parameters->masked[summary->detectorId(i)]) continue;
cHM->cd(i + 1);
TH2F* h = hitmap[summary->detectorId(i)];
if (h) {
CommonTools::suppressNoisyPixels(h, 10);
gStyle->SetOptStat("erm");
h->DrawCopy("colz");
}
}
// CORR HITMAP CANVAS
TCanvas *cHMC = new TCanvas("cHMC","Correlated rawhitmaps",720,720);
cHMC->cd();
cHMC->Divide(3,3);
for(int i = 0; i < summary->nDetectors(); ++i) {
if (parameters->masked[summary->detectorId(i)]) continue;
cHMC->cd(i + 1);
TH2F* h2 = corr_hitmap[summary->detectorId(i)];
if (h2) {
CommonTools::suppressNoisyPixels(h2, 10);
gStyle->SetOptStat("erm");
h2->DrawCopy("colz");
}
}
// OVERLAP HITMAP CANVAS
TCanvas *cHMO = new TCanvas("cHMO", "Hits that overlap in many detectors",720,720);
cHMO->cd();
cHMO->Divide(3, 3);
for (int i = 0; i < summary->nDetectors(); ++i) {
if (parameters->masked[summary->detectorId(i)]) continue;
cHMO->cd(i + 1);
TH2F* h3 = overlap_hitmap[summary->detectorId(i)];
if (h3) {
CommonTools::suppressNoisyPixels(h3,10);
gStyle->SetOptStat("erm");
h3->DrawCopy("colz");
}
}
//CORRELATION CANVAS
TCanvas *cCM = new TCanvas("cCol", "Detector 1 Correlation", 1200,400);
cCM->cd();
cCM->Divide(6, 2);
int ipad = 1;
for (int j = 0; j < summary->nDetectors(); ++j) {
if (parameters->masked[summary->detectorId(j)]) continue;
for (int k = 0; k < summary->nDetectors(); ++k) {
if (parameters->masked[summary->detectorId(k)]) continue;
if(ipad > 6) break;
if(row_correlation[summary->detectorId(j)][summary->detectorId(k)]){
cCM->cd(ipad);
row_correlation[summary->detectorId(j)][summary->detectorId(k)]->SetStats(0);
row_correlation[summary->detectorId(j)][summary->detectorId(k)]->DrawCopy("box");
cCM->cd(ipad+6);
col_correlation[summary->detectorId(j)][summary->detectorId(k)]->SetStats(0);
col_correlation[summary->detectorId(j)][summary->detectorId(k)]->DrawCopy("box");
ipad++;
}
}
}
TCanvas* cdiff = new TCanvas("cdiff", "Detector 1 diff", 1200,400);
cdiff->cd();
cdiff->Divide(6, 2);
ipad = 1;
for (int j = 0; j < summary->nDetectors(); ++j) {
if (parameters->masked[summary->detectorId(j)]) continue;
for (int k = 0; k < summary->nDetectors(); ++k) {
if (parameters->masked[summary->detectorId(k)]) continue;
if(ipad > 6) break;
if(row_difference[summary->detectorId(j)][summary->detectorId(k)]){
cdiff->cd(ipad);
row_difference[summary->detectorId(j)][summary->detectorId(k)]->SetStats(0);
double mu = row_difference[summary->detectorId(j)][summary->detectorId(k)]->GetMean();
double sigma = row_difference[summary->detectorId(j)][summary->detectorId(k)]->GetRMS();
double iniParams[4] = {6000, mu, 0.1*sigma, 1000};
double hiParams[4] = {40000, mu+20*sigma, 1*sigma,3000};
double lowParams[4] = {0,mu-20*sigma, 0.001*sigma,0};
TF1* func = new TF1("func", gausaddpol0, mu-5*sigma, mu+5*sigma,4);
for(int i=0; i<4; i++){
func->SetParameter(i, iniParams[i]);
func->SetParLimits(i,lowParams[i],hiParams[i]);
}
//row_difference[summary->detectorId(j)][summary->detectorId(k)]->Fit(func,"R");
row_difference[summary->detectorId(j)][summary->detectorId(k)]->DrawCopy();
cdiff->cd(ipad+6);
col_difference[summary->detectorId(j)][summary->detectorId(k)]->SetStats(0);
double mu2 = col_difference[summary->detectorId(j)][summary->detectorId(k)]->GetMean();
double sigma2 = col_difference[summary->detectorId(j)][summary->detectorId(k)]->GetRMS();
double iniParams2[4] = {6000, mu2, 0.1*sigma2, 1000};
double hiParams2[4] = {40000, mu2+5*sigma2, sigma2,3000};
double lowParams2[4] = {0,mu2-5*sigma2, 0.005*sigma2,0};
TF1 *func2 = new TF1("func2", gausaddpol0, mu2-0.2*sigma2, mu2+0.2*sigma2,4);
for(int h=0; h<4; h++){
func2->SetParameter(h, iniParams2[h]);
func2->SetParLimits(h,lowParams2[h],hiParams2[h]);
}
//col_difference[summary->detectorId(j)][summary->detectorId(k)]->Fit(func2);
col_difference[summary->detectorId(j)][summary->detectorId(k)]->DrawCopy();
++ipad;
}
}
}
}
void checkRsnPIDqa(TString filename, TString foldername, Bool_t savePng,
TString plotTPCpi, TString plotTPCka, TString plotTPCpro,
TString plotTTOFpi, TString plotTOFka, TString plotTOFpro)
{
//Open input file
TFile * fin = TFile::Open(filename.Data());
if (!fin) return 0x0;
//Access output of specific wagon
TList * list = (TList*) fin->Get(foldername.Data());
if (!list) return 0x0;
//Set range for fit
Float_t RangeFitMomMin = 0.1; //range in momentum where to check the mean and pull
Float_t RangeFitMomMax = 2.0;
Int_t xbinFitMin = 0;
Int_t xbinFitMax = -1;
Float_t RangeFitNsigmaPIDmin = -2.0; //range in Nsigma where the fit is to be performed
Float_t RangeFitNsigmaPIDmax = 2.0;
//Set range for visualisation
Float_t RangeShowTPC[2] = {0.1, 2.0};
Float_t RangeShowTOF[2] = {0.25, 2.0};
//--------------------------
// TPC PID Nsigma
// fit with simple gaussian
//--------------------------
//Gaussian function
TF1 *fGaus = new TF1("f","gaus", -7.0, 7.0);
//--- pions
TH2F * hTPCsigmaPi = (TH2F*)list->FindObject(plotTPCpi.Data());
hTPCsigmaPi->RebinX(2);
hTPCsigmaPi->SetTitle("TPC Pions");
MakeUpHisto(hTPCsigmaPi,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
hTPCsigmaPi->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaPi->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
xbinFitMin = hTPCsigmaPi->GetXaxis()->FindBin(RangeFitMomMin);
xbinFitMax = hTPCsigmaPi->GetXaxis()->FindBin(RangeFitMomMax);
hTPCsigmaPi->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
TH1D * hTPCsigmaPi_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCpi.Data())))->Clone("hNsigmaTPCpi_mean");
TH1D * hTPCsigmaPi_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCpi.Data())))->Clone("hNsigmaTPCpi_pull");
MakeUpHisto(hTPCsigmaPi_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaPi_pull, "", "", 1, kRed+2, 2);
//--- kaons
TH2F * hTPCsigmaKa = (TH2F*)list->FindObject(plotTPCka.Data());
hTPCsigmaKa->RebinX(2);
hTPCsigmaKa->SetTitle("TPC Kaons");
hTPCsigmaKa->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaKa->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
hTPCsigmaKa->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
MakeUpHisto(hTPCsigmaKa,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
TH1D * hTPCsigmaKa_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCka.Data())))->Clone("hNsigmaTPCka_mean");
TH1D * hTPCsigmaKa_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCka.Data())))->Clone("hNsigmaTPCka_pull");
MakeUpHisto(hTPCsigmaKa_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaKa_pull, "", "", 1, kRed+2, 2);
//--- protons
TH2F * hTPCsigmaPro = (TH2F*)list->FindObject(plotTPCpro.Data());
hTPCsigmaPro->RebinX(2);
hTPCsigmaPro->SetTitle("TPC Protons");
MakeUpHisto(hTPCsigmaPro,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
hTPCsigmaPro->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaPro->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
hTPCsigmaPro->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
TH1D * hTPCsigmaPro_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCpro.Data())))->Clone("hNsigmaTPCpro_mean");
TH1D * hTPCsigmaPro_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCpro.Data())))->Clone("hNsigmaTPCpro_pull");
MakeUpHisto(hTPCsigmaPro_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaPro_pull, "", "", 1, kRed+2, 2);
//--- plot TPC
TLine *l11=new TLine(RangeShowTPC[0],0.,RangeShowTPC[1],0.); l11->SetLineWidth(1); l11->SetLineStyle(7);
TLine *l12=new TLine(RangeShowTPC[0],1.,RangeShowTPC[1],1.); l12->SetLineWidth(1); l12->SetLineStyle(7);
gStyle->SetOptStat(0);
TCanvas *cPidPerformance4 = new TCanvas("cPIDperformance4","TPC PID",1200,500);
cPidPerformance4->Divide(3,1);
cPidPerformance4->cd(1);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaPi->DrawCopy("colz");
hTPCsigmaPi_mean->DrawCopy("same");
hTPCsigmaPi_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance4->cd(2);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaKa->DrawCopy("colz");
hTPCsigmaKa_mean->DrawCopy("same");
hTPCsigmaKa_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance4->cd(3);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaPro->DrawCopy("colz");
hTPCsigmaPro_mean->DrawCopy("same");
hTPCsigmaPro_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
TLegend * pidLegTPC = new TLegend(0.15,0.8,0.88,0.88);
pidLegTPC->SetBorderSize(0); pidLegTPC->SetFillStyle(1001); pidLegTPC->SetFillColor(kWhite);
pidLegTPC->SetTextSize(0.04); pidLegTPC->SetNColumns(2);
pidLegTPC->AddEntry(hTPCsigmaPro_mean,"Mean","lp");
pidLegTPC->AddEntry(hTPCsigmaPro_pull,Form("#sigma, Gaus fit (%2.1f,%2.1f)",RangeFitNsigmaPIDmin,RangeFitNsigmaPIDmax),"lp");
pidLegTPC->Draw("same");
if (savePng) cPidPerformance4->SaveAs("RsnQA_TPC_Nsigma.png");
//----------------------------------------------------
// TOF
// fit with signal model = gaussian + exponential tail
//----------------------------------------------------
//Signal model for TOF signal = gaus + exp tail
const Int_t npars = 6;
TF1 *fSignalModel = new TF1("fSignalModel", TOFsignal, -7.0, 7.0, npars);
fSignalModel->SetTitle("TOF Signal");
fSignalModel->SetParameter(0, 1.);
fSignalModel->SetParameter(1, 0.);
fSignalModel->SetParLimits(1, -2., 1.);
fSignalModel->SetParameter(2, 1.);
fSignalModel->SetParLimits(2, 0.5, 2.);
fSignalModel->SetParameter(3, 1.);
fSignalModel->SetParLimits(3, 0.5, 1.5);
fSignalModel->SetParameter(4, 1.);
fSignalModel->SetParLimits(4, 0., 1.e8);
fSignalModel->SetParameter(5, 0.);
fSignalModel->SetParLimits(5, -10., 10.);
fSignalModel->SetNpx(2000);
fSignalModel->SetParNames("Norm", "Mean", "Sigma", "Tail", "Shift", "Slope"/*, "Square"*/);
fSignalModel->SetLineColor(kRed+1);
//results
TObjArray *results[3];
for(Int_t i = 0; i < 3; i++){
results[i] = new TObjArray(10);
}
TH1D * par[3][npars];
//--- pions
TH2F * hTOFsigmaPi = (TH2F*)list->FindObject(plotTOFpi.Data());
hTOFsigmaPi->SetTitle("TOF Pions");
hTOFsigmaPi->RebinX(2);
MakeUpHisto(hTOFsigmaPi,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaPi->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaPi->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaPi->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaPi->GetMaximum()*1.2);
hTOFsigmaPi->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[0][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFpi.Data(), cc));
}
MakeUpHisto(par[0][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[0][2], "", "", 1, kMagenta+2, 2);
//--- KAONS
TH2F * hTOFsigmaKa = (TH2F*)list->FindObject(plotTOFka.Data());
hTOFsigmaKa->SetTitle("TOF Kaons");
hTOFsigmaKa->RebinX(2);
MakeUpHisto(hTOFsigmaKa,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaKa->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaKa->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaKa->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaKa->GetMaximum()*1.2);
hTOFsigmaKa->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[1][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFka.Data(), cc));
}
MakeUpHisto(par[1][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[1][2], "", "", 1, kMagenta+2, 2);
//--- protons
TH2F * hTOFsigmaPro = (TH2F*)list->FindObject(plotTOFpro.Data());
hTOFsigmaPro->SetTitle("TOF Protons");
hTOFsigmaPro->RebinX(2);
MakeUpHisto(hTOFsigmaPro,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaPro->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaPro->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaPro->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaPro->GetMaximum()*1.2);
hTOFsigmaPro->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[2][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFpro.Data(), cc));
}
MakeUpHisto(par[2][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[2][2], "", "", 1, kMagenta+2, 2);
//--- plot TOF
gStyle->SetOptStat(0);
TCanvas *cPidPerformance3 = new TCanvas("cPidPerformance3","TOF PID performance",1200,500);
cPidPerformance3->Divide(3,1);
cPidPerformance3->cd(1);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaPi->DrawCopy("colz");
if(par[0][1]) par[0][1]->DrawCopy("same");
if(par[0][2]) par[0][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance3->cd(2);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaKa->DrawCopy("colz");
if(par[1][1]) par[1][1]->DrawCopy("same");
if(par[1][2]) par[1][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance3->cd(3);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaPro->DrawCopy("colz");
if(par[2][1]) par[2][1]->DrawCopy("same");
if(par[2][2]) par[2][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
TLegend * pidLegTOF = new TLegend(0.15,0.8,0.88,0.88);
pidLegTOF->SetBorderSize(0); pidLegTOF->SetFillStyle(1001); pidLegTOF->SetFillColor(kWhite);
pidLegTOF->SetTextSize(0.04); pidLegTOF->SetNColumns(2);
pidLegTOF->AddEntry(par[0][1],"Mean","lp");
pidLegTOF->AddEntry(par[0][2], Form("#sigma, Gaus+Tail fit (%2.1f,%2.1f)",RangeFitNsigmaPIDmin, RangeFitNsigmaPIDmax),"lp");
pidLegTOF->Draw("same");
if (savePng) cPidPerformance3->Print("RsnQA_TOF_Nsigma.png");
return;
}
double* read(const char* fname = "~/Documents/noise/struckDataGregRun3/struck_run500.root", int bounds[], int bins=25000, int range=400000)
{
//Uncomment to use this file by itself to view energy spectra
//int bounds[] = {2500,2530,10185,10240, 11570,11625};
// Read From ROOT
TFile* f = new TFile(fname,"READ");
TTree* t = (TTree*)f->Get("SIS3302Decoder");
assert(t);
//cout <<t->GetEntries()<<endl;
UInt_t energy;
t->SetBranchStatus("*",0);
t->SetBranchStatus("energy",1);
t->SetBranchAddress("energy",&energy);
// t->Scan("energy");
int n = t->GetEntries();
int nbins = bins;
TH1F* h = new TH1F("h", "Energy Spectrum", nbins, 0, range);
for (int i=0; i<n; ++i) {
t->GetEntry(i);
h->Fill((Double_t)energy);
//cout <<i<<"\t"<<energy<<endl;
}
// Draw Energy Spectrum
TCanvas *c1 = new TCanvas("c1","Energy Spectrum",200,10,700,500);
c1->SetFillColor(0);
TH2F* zone = new TH2F("zone", "Gaussian; ADU; Energy", 1, 0, 100000000, 1, 0, 150);
zone->DrawCopy();
h->Draw();
// Integrate over gaussian to find # of counts
//cout <<"counts = "<<h->Integral(7943, 7973)<<endl;
// Fit Gaussians
double *width = new double[9];
h->Fit("gaus", "RQ", "", bounds[0], bounds[1]);
double constant = gaus->GetParameter(0);
double mean = gaus->GetParameter(1);
double sigma = gaus->GetParameter(2);
double error = gaus->GetParError(2);
double FWHM = 2.35*sigma;
width[0] = FWHM;
width[1] = mean;
width[2] = error*2.35;
//cout <<"error = "<<error<<endl;
h->Fit("gaus", "RQ", "", bounds[2],bounds[3]);
constant = gaus->GetParameter(0);
mean = gaus->GetParameter(1);
sigma = gaus->GetParameter(2);
error = gaus->GetParError(2);
FWHM = 2.35*sigma;
width[3] = FWHM;
width[4] = mean;
width[5] = error*2.35;
//histogram->GetFunction how to define gaus
h->Fit("gaus", "RQ", "", bounds[4],bounds[5]);
constant = gaus->GetParameter(0);
mean = gaus->GetParameter(1);
sigma = gaus->GetParameter(2);
error = gaus->GetParError(2);
FWHM = 2.35*sigma;
width[6] = FWHM;
width[7] = mean;
width[8] = error*2.35;
double deltaADC = width[7];
double deltaeV = 1330000;
double ADC_to_eV = deltaeV/deltaADC;
cout <<"means - "<<width[1]<<", "<<width[4]<<", "<<width[7]<<endl;
// Choose 1.33 MeV line as calibration point for other peaks
width[1] = ADC_to_eV*(width[1]) *1e-6;
width[4] = ADC_to_eV*(width[4]) *1e-6;
width[7] = 1.33;
width[0] *= ADC_to_eV;
width[2] *= ADC_to_eV;
width[3] *= ADC_to_eV;
width[5] *= ADC_to_eV;
width[6] *= ADC_to_eV;
width[8] *= ADC_to_eV;
cout <<"means - "<<width[1]<<", "<<width[4]<<", "<<width[7]<<endl;
return width;
char dummy = cin.get();
}
