{
"cells": [
{
"cell_type": "markdown",
"id": "3c47994e",
"metadata": {},
"source": [
"# rf606_nllerrorhandling\n",
"\n",
"'LIKELIHOOD AND MINIMIZATION' RooFit tutorial macro #606\n",
"\n",
"Understanding and customizing error handling in likelihood evaluations\n",
"\n",
"\n",
"\n",
"\n",
"**Author:** Clemens Lange, Wouter Verkerke (C version) \n",
"This notebook tutorial was automatically generated with ROOTBOOK-izer from the macro found in the ROOT repository on Tuesday, March 19, 2024 at 07:16 PM."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "857427f9",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:16:59.948164Z",
"iopub.status.busy": "2024-03-19T19:16:59.947747Z",
"iopub.status.idle": "2024-03-19T19:17:02.995107Z",
"shell.execute_reply": "2024-03-19T19:17:02.972317Z"
}
},
"outputs": [],
"source": [
"import ROOT"
]
},
{
"cell_type": "markdown",
"id": "71dc462c",
"metadata": {},
"source": [
"Create model and dataset\n",
"----------------------------------------------"
]
},
{
"cell_type": "markdown",
"id": "b7613243",
"metadata": {},
"source": [
"Observable"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "aab5dddb",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:03.010117Z",
"iopub.status.busy": "2024-03-19T19:17:03.009724Z",
"iopub.status.idle": "2024-03-19T19:17:03.815067Z",
"shell.execute_reply": "2024-03-19T19:17:03.804799Z"
}
},
"outputs": [],
"source": [
"m = ROOT.RooRealVar(\"m\", \"m\", 5.20, 5.30)"
]
},
{
"cell_type": "markdown",
"id": "ed04862f",
"metadata": {},
"source": [
"Parameters"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "71ea5f22",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:03.838004Z",
"iopub.status.busy": "2024-03-19T19:17:03.837599Z",
"iopub.status.idle": "2024-03-19T19:17:04.034532Z",
"shell.execute_reply": "2024-03-19T19:17:04.028802Z"
}
},
"outputs": [],
"source": [
"m0 = ROOT.RooRealVar(\"m0\", \"m0\", 5.291, 5.20, 5.30)\n",
"k = ROOT.RooRealVar(\"k\", \"k\", -30, -50, -10)"
]
},
{
"cell_type": "markdown",
"id": "cd025f29",
"metadata": {},
"source": [
"Pdf"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "218eeb0c",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:04.048869Z",
"iopub.status.busy": "2024-03-19T19:17:04.048394Z",
"iopub.status.idle": "2024-03-19T19:17:04.279391Z",
"shell.execute_reply": "2024-03-19T19:17:04.278269Z"
}
},
"outputs": [],
"source": [
"argus = ROOT.RooArgusBG(\"argus\", \"argus\", m, m0, k)"
]
},
{
"cell_type": "markdown",
"id": "049cf89a",
"metadata": {},
"source": [
"Sample 1000 events in m from argus"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "b10bc25b",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:04.306806Z",
"iopub.status.busy": "2024-03-19T19:17:04.306425Z",
"iopub.status.idle": "2024-03-19T19:17:04.567716Z",
"shell.execute_reply": "2024-03-19T19:17:04.566519Z"
}
},
"outputs": [],
"source": [
"data = argus.generate({m}, 1000)"
]
},
{
"cell_type": "markdown",
"id": "a66a85a5",
"metadata": {},
"source": [
"Plot model and data\n",
"--------------------------------------"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "c484a91a",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:04.575423Z",
"iopub.status.busy": "2024-03-19T19:17:04.574773Z",
"iopub.status.idle": "2024-03-19T19:17:05.100591Z",
"shell.execute_reply": "2024-03-19T19:17:05.098979Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"frame1 = m.frame(Bins=40, Title=\"Argus model and data\")\n",
"data.plotOn(frame1)\n",
"argus.plotOn(frame1)"
]
},
{
"cell_type": "markdown",
"id": "aecf10b2",
"metadata": {},
"source": [
"Fit model to data\n",
"---------------------------------"
]
},
{
"cell_type": "markdown",
"id": "1ef00059",
"metadata": {},
"source": [
"The ARGUS background shape has a sharp kinematic cutoff at m=m0\n",
"and is prone to evaluation errors if the cutoff parameter m0\n",
"is floated: when the pdf cutoff value is lower than that in data\n",
"events with m>m0 will have zero probability"
]
},
{
"cell_type": "markdown",
"id": "c13d90cf",
"metadata": {},
"source": [
"Perform unbinned ML fit. Print detailed error messages for up to\n",
"10 events per likelihood evaluation. The default error handling strategy\n",
"is to return a very high value of the likelihood to MINUIT if errors occur,\n",
"which will force MINUIT to retreat from the problematic area"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "28a63508",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:05.161738Z",
"iopub.status.busy": "2024-03-19T19:17:05.161249Z",
"iopub.status.idle": "2024-03-19T19:17:05.623114Z",
"shell.execute_reply": "2024-03-19T19:17:05.616568Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"[#1] INFO:Fitting -- RooAbsPdf::fitTo(argus_over_argus_Int[m]) fixing normalization set for coefficient determination to observables in data\n",
"[#1] INFO:Fitting -- using CPU computation library compiled with -mavx2\n",
"[#1] INFO:Fitting -- RooAddition::defaultErrorLevel(nll_argus_over_argus_Int[m]_argusData) Summation contains a RooNLLVar, using its error level\n",
"[#1] INFO:Minimization -- RooAbsMinimizerFcn::setOptimizeConst: activating const optimization\n",
"Minuit2Minimizer: Minimize with max-calls 1000 convergence for edm < 1 strategy 1\n",
"RooAbsMinimizerFcn: Minimized function has error status.\n",
"Returning maximum FCN so far (-2417.08) to force MIGRAD to back out of this region. Error log follows.\n",
"Parameter values: \tk=-33.8075\tm0=5.29014\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ]\n",
" getLogVal() top-level p.d.f not greater than zero @ numerator=argus=0.387202, denominator=argus_Int[m]=0.0305662\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status.\n",
"Returning maximum FCN so far (-2417.08) to force MIGRAD to back out of this region. Error log follows.\n",
"Parameter values: \tk=-36.7074\tm0=5.2901\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ]\n",
" getLogVal() top-level p.d.f not greater than zero @ numerator=argus=0.370612, denominator=argus_Int[m]=0.0290505\n",
"\n",
"Minuit2Minimizer : Valid minimum - status = 0\n",
"FVAL = -2419.30692128725559\n",
"Edm = 2.90497786168460102e-06\n",
"Nfcn = 47\n",
"k\t = -35.3713\t +/- 3.51942\t(limited)\n",
"m0\t = 5.2904\t +/- 0.000261877\t(limited)\n",
"[#1] INFO:Minimization -- RooAbsMinimizerFcn::setOptimizeConst: deactivating const optimization\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"Info in : MnSeedGenerator Computing seed using NumericalGradient calculator\n",
"Info in : MnSeedGenerator Initial state: FCN = -2417.48203 Edm = 1.59436124 NCalls = 7\n",
"Info in : MnSeedGenerator Initial state \n",
" Minimum value : -2417.48203\n",
" Edm : 1.59436124\n",
" Internal parameters:\t[ 0 0.9614110188]\t\n",
" Internal gradient :\t[ 6.430040774 66.49119995]\t\n",
" Internal covariance matrix:\n",
"[[ 0.059577243 0]\n",
" [ 0 0.00088534902]]]\n",
"Info in : VariableMetricBuilder Start iterating until Edm is < 0.001 with call limit = 1000\n",
"Info in : VariableMetricBuilder 0 - FCN = -2417.48203 Edm = 1.59436124 NCalls = 7\n",
"Info in : VariableMetricBuilder 1 - FCN = -2418.669621 Edm = 0.6597753344 NCalls = 15\n",
"Info in : VariableMetricBuilder 2 - FCN = -2419.092375 Edm = 0.3262165039 NCalls = 23\n",
"Info in : VariableMetricBuilder 3 - FCN = -2419.306527 Edm = 0.001182979929 NCalls = 29\n",
"Info in : VariableMetricBuilder 4 - FCN = -2419.306921 Edm = 3.048074013e-06 NCalls = 35\n",
"Info in : VariableMetricBuilder After Hessian\n",
"Info in : VariableMetricBuilder 5 - FCN = -2419.306921 Edm = 2.904977862e-06 NCalls = 47\n",
"Info in : Minuit2Minimizer::Hesse Using max-calls 1000\n",
"Info in : Minuit2Minimizer::Hesse Hesse is valid - matrix is accurate\n"
]
}
],
"source": [
"argus.fitTo(data, PrintEvalErrors=10)"
]
},
{
"cell_type": "markdown",
"id": "c5189a89",
"metadata": {},
"source": [
"Perform another fit. In self configuration only the number of errors per\n",
"likelihood evaluation is shown, it is greater than zero. The\n",
"EvalErrorWall(kFALSE) arguments disables the default error handling strategy\n",
"and will cause the actual (problematic) value of the likelihood to be passed\n",
"to MINUIT.\n",
"\n",
"NB: Use of self option is NOT recommended as default strategt as broken -log(L) values\n",
"can often be lower than 'good' ones because offending events are removed.\n",
"ROOT.This may effectively create a False minimum in problem areas. ROOT.This is clearly\n",
"illustrated in the second plot"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "45b5e209",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:05.645192Z",
"iopub.status.busy": "2024-03-19T19:17:05.644810Z",
"iopub.status.idle": "2024-03-19T19:17:06.170623Z",
"shell.execute_reply": "2024-03-19T19:17:06.169575Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"[#1] INFO:Fitting -- RooAbsPdf::fitTo(argus_over_argus_Int[m]) fixing normalization set for coefficient determination to observables in data\n",
"[#1] INFO:Fitting -- RooAddition::defaultErrorLevel(nll_argus_over_argus_Int[m]_argusData) Summation contains a RooNLLVar, using its error level\n",
"[#1] INFO:Minimization -- RooAbsMinimizerFcn::setOptimizeConst: activating const optimization\n",
"Minuit2Minimizer: Minimize with max-calls 1000 convergence for edm < 1 strategy 1\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.28877\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 4 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=nan\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=nan\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 2000 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.27133\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 166 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.28726\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 9 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.2898\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 1 errors\n",
"\n",
"Minuit2Minimizer : Invalid Minimum - status = 3\n",
"FVAL = -2419.31\n",
"Edm = -nan\n",
"Nfcn = 34\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.2898\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 1 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.28374\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 44 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.27133\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 166 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.28726\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 9 errors\n",
"\n",
"RooAbsMinimizerFcn: Minimized function has error status but is ignored.\n",
"Parameter values: \tk=-35.3713\tm0=5.2898\n",
"RooAbsPdf::argus_over_argus_Int[m][ numerator=argus denominator=argus_Int[m] ] has 1 errors\n",
"\n",
"[#1] INFO:Minimization -- RooAbsMinimizerFcn::setOptimizeConst: deactivating const optimization\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"Info in : MnSeedGenerator Computing seed using NumericalGradient calculator\n",
"Info in : MnSeedGenerator Initial state: FCN = -2419.306921 Edm = nan NCalls = 9\n",
"Info in : MnSeedGenerator Initial state \n",
" Minimum value : -2419.306921\n",
" Edm : nan\n",
" Internal parameters:\t[ -0.2719048895 0.940796957]\t\n",
" Internal gradient :\t[ -0.0131804372 nan]\t\n",
" Internal covariance matrix:\n",
"[[ 0.065014457 0]\n",
" [ 0 2]]]\n",
"Info in : VariableMetricBuilder Start iterating until Edm is < 0.001 with call limit = 1000\n",
"Info in : VariableMetricBuilder 0 - FCN = -2419.306921 Edm = nan NCalls = 9\n",
"Warning in : VariableMetricBuilder No improvement in line search\n",
"Info in : VariableMetricBuilder 1 - FCN = -2419.306921 Edm = nan NCalls = 20\n",
"Warning in : MnPosDef Matrix forced pos-def by adding to diagonal nan\n",
"Info in : VariableMetricBuilder After Hessian\n",
"Info in : VariableMetricBuilder 2 - FCN = -2419.306921 Edm = -nan NCalls = 34\n",
"Info in : VariableMetricBuilder Edm has been re-computed after Hesse; Edm -nan is now within tolerance\n",
"Warning in : Minuit2Minimizer::Minimize Minimization did NOT converge, Edm is above max\n",
"Info in : Minuit2Minimizer::Hesse Using max-calls 1000\n",
"Warning in : MnPosDef Matrix forced pos-def by adding to diagonal nan\n",
"Info in : Minuit2Minimizer::Hesse Hesse is valid - matrix is full but made positive defined\n"
]
}
],
"source": [
"m0.setError(0.1)\n",
"argus.fitTo(data, PrintEvalErrors=0, EvalErrorWall=False)"
]
},
{
"cell_type": "markdown",
"id": "c8810e80",
"metadata": {},
"source": [
"Plot likelihood as function of m0\n",
"------------------------------------------------------------------"
]
},
{
"cell_type": "markdown",
"id": "6e09f115",
"metadata": {},
"source": [
"Construct likelihood function of model and data"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "ac6913ba",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:06.190492Z",
"iopub.status.busy": "2024-03-19T19:17:06.189779Z",
"iopub.status.idle": "2024-03-19T19:17:06.420031Z",
"shell.execute_reply": "2024-03-19T19:17:06.415203Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[#1] INFO:Fitting -- RooAbsPdf::fitTo(argus_over_argus_Int[m]) fixing normalization set for coefficient determination to observables in data\n"
]
}
],
"source": [
"nll = argus.createNLL(data)"
]
},
{
"cell_type": "markdown",
"id": "06e08ed0",
"metadata": {},
"source": [
"Plot likelihood in m0 in range that includes problematic values\n",
"In self configuration no messages are printed for likelihood evaluation errors,\n",
"but if an likelihood value evaluates with error, corresponding value\n",
"on the curve will be set to the value given in EvalErrorValue()."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "8b15c4d6",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:06.436188Z",
"iopub.status.busy": "2024-03-19T19:17:06.435580Z",
"iopub.status.idle": "2024-03-19T19:17:07.435598Z",
"shell.execute_reply": "2024-03-19T19:17:07.434452Z"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Info in : png file rf606_nllerrorhandling.png has been created\n"
]
}
],
"source": [
"frame2 = m0.frame(Range=(5.288, 5.293), Title=\"-log(L) scan vs m0, regions masked\")\n",
"nll.plotOn(frame2, ShiftToZero=True, PrintEvalErrors=-1, EvalErrorValue=(nll.getVal() + 10), LineColor=\"r\")\n",
"frame2.SetMaximum(15)\n",
"frame2.SetMinimum(0)\n",
"\n",
"c = ROOT.TCanvas(\"rf606_nllerrorhandling\", \"rf606_nllerrorhandling\", 1200, 400)\n",
"c.Divide(2)\n",
"c.cd(1)\n",
"ROOT.gPad.SetLeftMargin(0.15)\n",
"frame1.GetYaxis().SetTitleOffset(1.4)\n",
"frame1.Draw()\n",
"c.cd(2)\n",
"ROOT.gPad.SetLeftMargin(0.15)\n",
"frame2.GetYaxis().SetTitleOffset(1.4)\n",
"frame2.Draw()\n",
"\n",
"c.SaveAs(\"rf606_nllerrorhandling.png\")"
]
},
{
"cell_type": "markdown",
"id": "07a8af6f",
"metadata": {},
"source": [
"Draw all canvases "
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "cbbd9b49",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2024-03-19T19:17:07.451924Z",
"iopub.status.busy": "2024-03-19T19:17:07.450858Z",
"iopub.status.idle": "2024-03-19T19:17:07.877644Z",
"shell.execute_reply": "2024-03-19T19:17:07.874693Z"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from ROOT import gROOT \n",
"gROOT.GetListOfCanvases().Draw()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
}
},
"nbformat": 4,
"nbformat_minor": 5
}