Skip to content

Commit b9f0eca

Browse files
lubynetslubynets
committed
runMassFitter: do not repeat code when isMc==true or false
1 parent 5c34a7d commit b9f0eca

File tree

2 files changed

+114
-191
lines changed

2 files changed

+114
-191
lines changed

‎PWGHF/D2H/Macros/HFInvMassFitter.cxx‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,10 @@ void HFInvMassFitter::doFit()
203203
mIntegralSgn = signalIntegralMc->getValV();
204204
calculateSignal(mRawYield, mRawYieldErr); // calculate signal and signal error
205205
mTotalPdf->plotOn(mInvMassFrame, Name("Tot_c")); // plot total function
206-
} else { // data
206+
// Fit to data ratio
207+
mRatioFrame = mass->frame(Title(Form("%s", mHistoInvMass->GetTitle())));
208+
calculateFitToDataRatio();
209+
} else { // data
207210
mBkgPdf = new RooAddPdf("mBkgPdf", "background fit function", RooArgList(*bkgPdf), RooArgList(*mRooNBkg));
208211
if (mTypeOfSgnPdf == GausSec) { // two peak fit
209212
if (strcmp(mFitOption.c_str(), "Chi2") == 0) {

‎PWGHF/D2H/Macros/runMassFitter.C‎

Lines changed: 110 additions & 190 deletions
Original file line numberDiff line numberDiff line change
@@ -204,6 +204,9 @@ int runMassFitter(const std::string& configFileName)
204204
throw std::runtime_error("ERROR: only Expo, Poly1, Poly2, Pow and PowEx background functions supported! Exit");
205205
}
206206
bkgFunc[iSliceVar] = bkgFuncConfig[iSliceVar];
207+
if (isMc && bkgFunc[iSliceVar] != HFInvMassFitter::NoBkg) {
208+
throw std::runtime_error("ERROR: in MC mode the background function must be NoBkg! Exit");
209+
}
207210

208211
if (sgnFuncConfig[iSliceVar] < 0 || sgnFuncConfig[iSliceVar] >= HFInvMassFitter::NTypesOfSgnPdf) {
209212
throw std::runtime_error("ERROR: only SingleGaus, DoubleGaus and DoubleGausSigmaRatioPar signal functions supported! Exit");
@@ -369,17 +372,14 @@ int runMassFitter(const std::string& configFileName)
369372
canvasSize[0], canvasSize[1]);
370373
divideCanvas(canvasMass[iCanvas], nPads);
371374

372-
canvasResiduals[iCanvas] =
373-
new TCanvas(Form("canvasResiduals%d", iCanvas), Form("canvasResiduals%d", iCanvas), canvasSize[0], canvasSize[1]);
375+
canvasResiduals[iCanvas] = new TCanvas(Form("canvasResiduals%d", iCanvas), Form("canvasResiduals%d", iCanvas), canvasSize[0], canvasSize[1]);
374376
divideCanvas(canvasResiduals[iCanvas], nPads);
375377

376-
canvasRatio[iCanvas] = new TCanvas(Form("canvasRatio%d", iCanvas), Form("canvasRatio%d", iCanvas),
377-
canvasSize[0], canvasSize[1]);
378+
canvasRatio[iCanvas] = new TCanvas(Form("canvasRatio%d", iCanvas), Form("canvasRatio%d", iCanvas), canvasSize[0], canvasSize[1]);
378379
divideCanvas(canvasRatio[iCanvas], nPads);
379380

380381
if (enableRefl) {
381-
canvasRefl[iCanvas] = new TCanvas(Form("canvasRefl%d", iCanvas), Form("canvasRefl%d", iCanvas),
382-
canvasSize[0], canvasSize[1]);
382+
canvasRefl[iCanvas] = new TCanvas(Form("canvasRefl%d", iCanvas), Form("canvasRefl%d", iCanvas), canvasSize[0], canvasSize[1]);
383383
divideCanvas(canvasRefl[iCanvas], nPads);
384384
}
385385
}
@@ -402,191 +402,111 @@ int runMassFitter(const std::string& configFileName)
402402

403403
double reflOverSgn = 0;
404404

405-
if (isMc) {
406-
HFInvMassFitter* massFitter;
407-
massFitter = new HFInvMassFitter(hMassForFit[iSliceVar], massMin[iSliceVar], massMax[iSliceVar], HFInvMassFitter::NoBkg, sgnFunc[iSliceVar]);
408-
massFitter->setDrawBgPrefit(drawBgPrefit);
409-
massFitter->setHighlightPeakRegion(highlightPeakRegion);
410-
massFitter->setInitialGaussianMean(massPDG);
411-
massFitter->setParticlePdgMass(massPDG);
412-
massFitter->setBoundGaussianMean(massPDG, 0.8 * massPDG, 1.2 * massPDG);
413-
if (useLikelihood) {
414-
massFitter->setUseLikelihoodFit();
415-
} else {
416-
massFitter->setUseChi2Fit();
417-
}
418-
massFitter->doFit();
419-
420-
if (nSliceVarBins > 1) {
421-
canvasMass[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
422-
} else {
423-
canvasMass[iCanvas]->cd();
424-
}
425-
426-
massFitter->drawFit(gPad, plotLabels, writeSignalPar);
427-
428-
const double rawYield = massFitter->getRawYield();
429-
const double rawYieldErr = massFitter->getRawYieldError();
430-
const double rawYieldCounted = massFitter->getRawYieldCounted();
431-
const double rawYieldCountedErr = massFitter->getRawYieldCountedError();
432-
const double reducedChiSquareBkg = massFitter->getChiSquareOverNDFBkg();
433-
const double reducedChiSquareTotal = massFitter->getChiSquareOverNDFTotal();
434-
const double mean = massFitter->getMean();
435-
const double meanErr = massFitter->getMeanUncertainty();
436-
const double sigma = massFitter->getSigma();
437-
const double sigmaErr = massFitter->getSigmaUncertainty();
438-
439-
hRawYieldsSignal->SetBinContent(iSliceVar + 1, rawYield);
440-
hRawYieldsSignal->SetBinError(iSliceVar + 1, rawYieldErr);
441-
hRawYieldsSignalCounted->SetBinContent(iSliceVar + 1, rawYieldCounted);
442-
hRawYieldsSignalCounted->SetBinError(iSliceVar + 1, rawYieldCountedErr);
443-
hRawYieldsChiSquareBkg->SetBinContent(iSliceVar + 1, reducedChiSquareBkg);
444-
hRawYieldsChiSquareBkg->SetBinError(iSliceVar + 1, 0.);
445-
hRawYieldsChiSquareTotal->SetBinContent(iSliceVar + 1, reducedChiSquareTotal);
446-
hRawYieldsChiSquareTotal->SetBinError(iSliceVar + 1, 0.);
447-
hRawYieldsMean->SetBinContent(iSliceVar + 1, mean);
448-
hRawYieldsMean->SetBinError(iSliceVar + 1, meanErr);
449-
hRawYieldsSigma->SetBinContent(iSliceVar + 1, sigma);
450-
hRawYieldsSigma->SetBinError(iSliceVar + 1, sigmaErr);
451-
452-
if (sgnFunc[iSliceVar] != HFInvMassFitter::SingleGaus) {
453-
const double secSigma = massFitter->getSecSigma();
454-
const double secSigmaErr = massFitter->getSecSigmaUncertainty();
455-
hRawYieldsSecSigma->SetBinContent(iSliceVar + 1, secSigma);
456-
hRawYieldsSecSigma->SetBinError(iSliceVar + 1, secSigmaErr);
457-
}
458-
if (sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGaus || sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGausSigmaRatioPar) {
459-
const double fracDoubleGaus = massFitter->getFracDoubleGaus();
460-
const double fracDoubleGausErr = massFitter->getFracDoubleGausUncertainty();
461-
hRawYieldsFracDoubleGaus->SetBinContent(iSliceVar + 1, fracDoubleGaus);
462-
hRawYieldsFracDoubleGaus->SetBinError(iSliceVar + 1, fracDoubleGausErr);
463-
}
405+
HFInvMassFitter* massFitter = new HFInvMassFitter(hMassForFit[iSliceVar], massMin[iSliceVar], massMax[iSliceVar], bkgFunc[iSliceVar], sgnFunc[iSliceVar]);
406+
massFitter->setDrawBgPrefit(drawBgPrefit);
407+
massFitter->setHighlightPeakRegion(highlightPeakRegion);
408+
massFitter->setInitialGaussianMean(massPDG);
409+
massFitter->setParticlePdgMass(massPDG);
410+
massFitter->setBoundGaussianMean(massPDG, 0.8 * massPDG, 1.2 * massPDG);
411+
if (useLikelihood) {
412+
massFitter->setUseLikelihoodFit();
464413
} else {
465-
HFInvMassFitter* massFitter;
466-
massFitter = new HFInvMassFitter(hMassForFit[iSliceVar], massMin[iSliceVar], massMax[iSliceVar],
467-
bkgFunc[iSliceVar], sgnFunc[iSliceVar]);
468-
massFitter->setDrawBgPrefit(drawBgPrefit);
469-
massFitter->setHighlightPeakRegion(highlightPeakRegion);
470-
massFitter->setInitialGaussianMean(massPDG);
471-
massFitter->setParticlePdgMass(massPDG);
472-
massFitter->setBoundGaussianMean(massPDG, 0.8 * massPDG, 1.2 * massPDG);
473-
if (useLikelihood) {
474-
massFitter->setUseLikelihoodFit();
475-
} else {
476-
massFitter->setUseChi2Fit();
477-
}
414+
massFitter->setUseChi2Fit();
415+
}
478416

479-
auto setFixedValue = [&iSliceVar](bool const& isFix, std::vector<double> const& fixManual, const TH1* histToFix, std::function<void(double)> setFunc, std::string const& var) -> void {
480-
if (isFix) {
481-
const auto valueToFix = fixManual.empty() ? histToFix->GetBinContent(iSliceVar + 1) : fixManual[iSliceVar];
482-
setFunc(valueToFix);
483-
printf("*****************************\n");
484-
printf("FIXED %s: %f\n", var.data(), valueToFix);
485-
printf("*****************************\n");
417+
auto setFixedValue = [&iSliceVar](bool const& isFix, std::vector<double> const& fixManual, const TH1* histToFix, std::function<void(double)> setFunc, std::string const& var) -> void {
418+
if (isFix) {
419+
if (fixManual.empty() && histToFix == nullptr) {
420+
throw std::runtime_error("Histogram to fix " + var + " is null while isFix==true and fixManual is empty");
486421
}
487-
};
488-
489-
setFixedValue(fixMean, fixMeanManual, hMeanToFix, std::bind(&HFInvMassFitter::setFixGaussianMean, massFitter, std::placeholders::_1), "MEAN");
490-
setFixedValue(fixSigma, fixSigmaManual, hSigmaToFix, std::bind(&HFInvMassFitter::setFixGaussianSigma, massFitter, std::placeholders::_1), "SIGMA");
491-
setFixedValue(fixSecondSigma, fixSecondSigmaManual, hSecondSigmaToFix, std::bind(&HFInvMassFitter::setFixSecondGaussianSigma, massFitter, std::placeholders::_1), "SECOND SIGMA");
492-
setFixedValue(fixFracDoubleGaus, fixFracDoubleGausManual, hFracDoubleGausToFix, std::bind(&HFInvMassFitter::setFixFrac2Gaus, massFitter, std::placeholders::_1), "FRAC DOUBLE GAUS");
493-
494-
if (enableRefl) {
495-
reflOverSgn = hMassForSgn[iSliceVar]->Integral(hMassForSgn[iSliceVar]->FindBin(massMin[iSliceVar] * 1.0001), hMassForSgn[iSliceVar]->FindBin(massMax[iSliceVar] * 0.999));
496-
reflOverSgn = hMassForRefl[iSliceVar]->Integral(hMassForRefl[iSliceVar]->FindBin(massMin[iSliceVar] * 1.0001), hMassForRefl[iSliceVar]->FindBin(massMax[iSliceVar] * 0.999)) / reflOverSgn;
497-
massFitter->setFixReflOverSgn(reflOverSgn);
498-
massFitter->setTemplateReflections(hMassRefl[iSliceVar]);
422+
const auto valueToFix = fixManual.empty() ? histToFix->GetBinContent(iSliceVar + 1) : fixManual[iSliceVar];
423+
setFunc(valueToFix);
424+
printf("*****************************\n");
425+
printf("FIXED %s: %f\n", var.data(), valueToFix);
426+
printf("*****************************\n");
499427
}
428+
};
429+
430+
setFixedValue(fixMean, fixMeanManual, hMeanToFix, std::bind(&HFInvMassFitter::setFixGaussianMean, massFitter, std::placeholders::_1), "MEAN");
431+
setFixedValue(fixSigma, fixSigmaManual, hSigmaToFix, std::bind(&HFInvMassFitter::setFixGaussianSigma, massFitter, std::placeholders::_1), "SIGMA");
432+
setFixedValue(fixSecondSigma, fixSecondSigmaManual, hSecondSigmaToFix, std::bind(&HFInvMassFitter::setFixSecondGaussianSigma, massFitter, std::placeholders::_1), "SECOND SIGMA");
433+
setFixedValue(fixFracDoubleGaus, fixFracDoubleGausManual, hFracDoubleGausToFix, std::bind(&HFInvMassFitter::setFixFrac2Gaus, massFitter, std::placeholders::_1), "FRAC DOUBLE GAUS");
434+
435+
if (!isMc && enableRefl) {
436+
reflOverSgn = hMassForSgn[iSliceVar]->Integral(hMassForSgn[iSliceVar]->FindBin(massMin[iSliceVar] * 1.0001), hMassForSgn[iSliceVar]->FindBin(massMax[iSliceVar] * 0.999));
437+
reflOverSgn = hMassForRefl[iSliceVar]->Integral(hMassForRefl[iSliceVar]->FindBin(massMin[iSliceVar] * 1.0001), hMassForRefl[iSliceVar]->FindBin(massMax[iSliceVar] * 0.999)) / reflOverSgn;
438+
massFitter->setFixReflOverSgn(reflOverSgn);
439+
massFitter->setTemplateReflections(hMassRefl[iSliceVar]);
440+
}
500441

501-
massFitter->doFit();
502-
503-
const double rawYield = massFitter->getRawYield();
504-
const double rawYieldErr = massFitter->getRawYieldError();
505-
const double rawYieldCounted = massFitter->getRawYieldCounted();
506-
const double rawYieldCountedErr = massFitter->getRawYieldCountedError();
507-
const double bkg = massFitter->getBkgYield();
508-
const double bkgErr = massFitter->getBkgYieldError();
509-
const double significance = massFitter->getSignificance();
510-
const double significanceErr = massFitter->getSignificanceError();
511-
const double reducedChiSquareBkg = massFitter->getChiSquareOverNDFBkg();
512-
const double reducedChiSquareTotal = massFitter->getChiSquareOverNDFTotal();
513-
const double mean = massFitter->getMean();
514-
const double meanErr = massFitter->getMeanUncertainty();
515-
const double sigma = massFitter->getSigma();
516-
const double sigmaErr = massFitter->getSigmaUncertainty();
517-
518-
hRawYieldsSignal->SetBinContent(iSliceVar + 1, rawYield);
519-
hRawYieldsSignal->SetBinError(iSliceVar + 1, rawYieldErr);
520-
hRawYieldsSignalCounted->SetBinContent(iSliceVar + 1, rawYieldCounted);
521-
hRawYieldsSignalCounted->SetBinError(iSliceVar + 1, rawYieldCountedErr);
522-
hRawYieldsBkg->SetBinContent(iSliceVar + 1, bkg);
523-
hRawYieldsBkg->SetBinError(iSliceVar + 1, bkgErr);
524-
hRawYieldsSgnOverBkg->SetBinContent(iSliceVar + 1, rawYield / bkg);
525-
hRawYieldsSgnOverBkg->SetBinError(iSliceVar + 1, rawYield / bkg * std::sqrt(rawYieldErr / rawYield * rawYieldErr / rawYield + bkgErr / bkg * bkgErr / bkg));
526-
hRawYieldsSignificance->SetBinContent(iSliceVar + 1, significance);
527-
hRawYieldsSignificance->SetBinError(iSliceVar + 1, significanceErr);
528-
hRawYieldsChiSquareBkg->SetBinContent(iSliceVar + 1, reducedChiSquareBkg);
529-
hRawYieldsChiSquareBkg->SetBinError(iSliceVar + 1, 1.e-20);
530-
hRawYieldsChiSquareTotal->SetBinContent(iSliceVar + 1, reducedChiSquareTotal);
531-
hRawYieldsChiSquareTotal->SetBinError(iSliceVar + 1, 1.e-20);
532-
hRawYieldsMean->SetBinContent(iSliceVar + 1, mean);
533-
hRawYieldsMean->SetBinError(iSliceVar + 1, meanErr);
534-
hRawYieldsSigma->SetBinContent(iSliceVar + 1, sigma);
535-
hRawYieldsSigma->SetBinError(iSliceVar + 1, sigmaErr);
536-
537-
if (sgnFunc[iSliceVar] != HFInvMassFitter::SingleGaus) {
538-
const double secSigma = massFitter->getSecSigma();
539-
const double secSigmaErr = massFitter->getSecSigmaUncertainty();
540-
hRawYieldsSecSigma->SetBinContent(iSliceVar + 1, secSigma);
541-
hRawYieldsSecSigma->SetBinError(iSliceVar + 1, secSigmaErr);
542-
}
543-
if (sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGaus || sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGausSigmaRatioPar) {
544-
const double fracDoubleGaus = massFitter->getFracDoubleGaus();
545-
const double fracDoubleGausErr = massFitter->getFracDoubleGausUncertainty();
546-
hRawYieldsFracDoubleGaus->SetBinContent(iSliceVar + 1, fracDoubleGaus);
547-
hRawYieldsFracDoubleGaus->SetBinError(iSliceVar + 1, fracDoubleGausErr);
548-
}
549-
550-
if (enableRefl) {
551-
hReflectionOverSignal->SetBinContent(iSliceVar + 1, reflOverSgn);
552-
if (nSliceVarBins > 1) {
553-
canvasRefl[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
554-
} else {
555-
canvasRefl[iCanvas]->cd();
556-
}
557-
massFitter->drawReflection(gPad);
558-
canvasRefl[iCanvas]->Modified();
559-
canvasRefl[iCanvas]->Update();
560-
}
442+
massFitter->doFit();
561443

444+
auto drawOnCanvas = [&](std::vector<TCanvas*>& canvas, std::function<void()> drawer) {
562445
if (nSliceVarBins > 1) {
563-
canvasMass[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
446+
canvas[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
564447
} else {
565-
canvasMass[iCanvas]->cd();
566-
}
567-
massFitter->drawFit(gPad, plotLabels, writeSignalPar);
568-
canvasMass[iCanvas]->Modified();
569-
canvasMass[iCanvas]->Update();
570-
571-
if (bkgFunc[iSliceVar] != HFInvMassFitter::NoBkg) {
572-
if (nSliceVarBins > 1) {
573-
canvasResiduals[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
574-
} else {
575-
canvasResiduals[iCanvas]->cd();
576-
}
577-
massFitter->drawResidual(gPad);
578-
canvasResiduals[iCanvas]->Modified();
579-
canvasResiduals[iCanvas]->Update();
580-
581-
if (nSliceVarBins > 1) {
582-
canvasRatio[iCanvas]->cd(iSliceVar - nCanvasesMax * iCanvas + 1);
583-
} else {
584-
canvasRatio[iCanvas]->cd();
585-
}
586-
massFitter->drawRatio(gPad);
587-
canvasRatio[iCanvas]->Modified();
588-
canvasRatio[iCanvas]->Update();
448+
canvas[iCanvas]->cd();
589449
}
450+
drawer();
451+
canvas[iCanvas]->Modified();
452+
canvas[iCanvas]->Update();
453+
};
454+
455+
drawOnCanvas(canvasMass, [&]() { massFitter->drawFit(gPad, plotLabels, writeSignalPar); });
456+
drawOnCanvas(canvasRatio, [&]() { massFitter->drawRatio(gPad); });
457+
if (bkgFunc[iSliceVar] != HFInvMassFitter::NoBkg) {
458+
drawOnCanvas(canvasResiduals, [&]() { massFitter->drawResidual(gPad); });
459+
}
460+
if (enableRefl) {
461+
drawOnCanvas(canvasRefl, [&]() { massFitter->drawReflection(gPad); });
462+
}
463+
464+
const double rawYield = massFitter->getRawYield();
465+
const double rawYieldErr = massFitter->getRawYieldError();
466+
const double rawYieldCounted = massFitter->getRawYieldCounted();
467+
const double rawYieldCountedErr = massFitter->getRawYieldCountedError();
468+
const double bkg = massFitter->getBkgYield();
469+
const double bkgErr = massFitter->getBkgYieldError();
470+
const double significance = massFitter->getSignificance();
471+
const double significanceErr = massFitter->getSignificanceError();
472+
const double reducedChiSquareBkg = massFitter->getChiSquareOverNDFBkg();
473+
const double reducedChiSquareTotal = massFitter->getChiSquareOverNDFTotal();
474+
const double mean = massFitter->getMean();
475+
const double meanErr = massFitter->getMeanUncertainty();
476+
const double sigma = massFitter->getSigma();
477+
const double sigmaErr = massFitter->getSigmaUncertainty();
478+
479+
hRawYieldsSignal->SetBinContent(iSliceVar + 1, rawYield);
480+
hRawYieldsSignal->SetBinError(iSliceVar + 1, rawYieldErr);
481+
hRawYieldsSignalCounted->SetBinContent(iSliceVar + 1, rawYieldCounted);
482+
hRawYieldsSignalCounted->SetBinError(iSliceVar + 1, rawYieldCountedErr);
483+
hRawYieldsBkg->SetBinContent(iSliceVar + 1, bkg);
484+
hRawYieldsBkg->SetBinError(iSliceVar + 1, bkgErr);
485+
hRawYieldsSgnOverBkg->SetBinContent(iSliceVar + 1, rawYield / bkg);
486+
hRawYieldsSgnOverBkg->SetBinError(iSliceVar + 1, rawYield / bkg * std::sqrt(rawYieldErr / rawYield * rawYieldErr / rawYield + bkgErr / bkg * bkgErr / bkg));
487+
hRawYieldsSignificance->SetBinContent(iSliceVar + 1, significance);
488+
hRawYieldsSignificance->SetBinError(iSliceVar + 1, significanceErr);
489+
hRawYieldsChiSquareBkg->SetBinContent(iSliceVar + 1, reducedChiSquareBkg);
490+
hRawYieldsChiSquareBkg->SetBinError(iSliceVar + 1, 1.e-20);
491+
hRawYieldsChiSquareTotal->SetBinContent(iSliceVar + 1, reducedChiSquareTotal);
492+
hRawYieldsChiSquareTotal->SetBinError(iSliceVar + 1, 1.e-20);
493+
hRawYieldsMean->SetBinContent(iSliceVar + 1, mean);
494+
hRawYieldsMean->SetBinError(iSliceVar + 1, meanErr);
495+
hRawYieldsSigma->SetBinContent(iSliceVar + 1, sigma);
496+
hRawYieldsSigma->SetBinError(iSliceVar + 1, sigmaErr);
497+
hReflectionOverSignal->SetBinContent(iSliceVar + 1, reflOverSgn);
498+
499+
if (sgnFunc[iSliceVar] != HFInvMassFitter::SingleGaus) { // TODO foresee DSCB and Voigt cases
500+
const double secSigma = massFitter->getSecSigma();
501+
const double secSigmaErr = massFitter->getSecSigmaUncertainty();
502+
hRawYieldsSecSigma->SetBinContent(iSliceVar + 1, secSigma);
503+
hRawYieldsSecSigma->SetBinError(iSliceVar + 1, secSigmaErr);
504+
}
505+
if (sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGaus || sgnFunc[iSliceVar] == HFInvMassFitter::DoubleGausSigmaRatioPar) {
506+
const double fracDoubleGaus = massFitter->getFracDoubleGaus();
507+
const double fracDoubleGausErr = massFitter->getFracDoubleGausUncertainty();
508+
hRawYieldsFracDoubleGaus->SetBinContent(iSliceVar + 1, fracDoubleGaus);
509+
hRawYieldsFracDoubleGaus->SetBinError(iSliceVar + 1, fracDoubleGausErr);
590510
}
591511

592512
hFitConfig->SetBinContent(ConfigMassMin, iSliceVar + 1, massMin[iSliceVar]);
@@ -656,14 +576,14 @@ int runMassFitter(const std::string& configFileName)
656576
if (iCanvas == nCanvases - 1 && nCanvases > 1) {
657577
canvasResiduals[iCanvas]->SaveAs(Form("%s]", outputFileNameResidual.Data()));
658578
}
659-
// ratio
660-
if (iCanvas == 0 && nCanvases > 1) {
661-
canvasRatio[iCanvas]->SaveAs(Form("%s[", outputFileRatio.Data()));
662-
}
663-
canvasRatio[iCanvas]->SaveAs(outputFileRatio.Data());
664-
if (iCanvas == nCanvases - 1 && nCanvases > 1) {
665-
canvasRatio[iCanvas]->SaveAs(Form("%s]", outputFileRatio.Data()));
666-
}
579+
}
580+
// ratio
581+
if (iCanvas == 0 && nCanvases > 1) {
582+
canvasRatio[iCanvas]->SaveAs(Form("%s[", outputFileRatio.Data()));
583+
}
584+
canvasRatio[iCanvas]->SaveAs(outputFileRatio.Data());
585+
if (iCanvas == nCanvases - 1 && nCanvases > 1) {
586+
canvasRatio[iCanvas]->SaveAs(Form("%s]", outputFileRatio.Data()));
667587
}
668588
}
669589
return 0;

0 commit comments

Comments
 (0)