diff --git a/examples/Example1.ipynb b/examples/Example1.ipynb index 9933d97..93e9b2d 100644 --- a/examples/Example1.ipynb +++ b/examples/Example1.ipynb @@ -6,12 +6,7 @@ "source": [ "# Example 1\n", "\n", - "Create a simple workspace with a very specialized method and run toys.\n", - "\n", - "See also the script `submit.condor` to submit to HT Condor.\n", - "e.g. on lxplus just run\n", - "\n", - " condor_submit submit.condor" + "Create a workspace without systematics and simple interpretation of the number of events." ] }, { @@ -23,7 +18,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Welcome to JupyROOT 6.14/04\n" + "Welcome to JupyROOT 6.14/08\n" ] } ], @@ -36,30 +31,45 @@ "countingworkspace.utils.silence_roofit()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the number of generated signal events ($T$) for each process $p$, the number of background events $b$ for each category $c$ and the probability ($\\varepsilon$) for an event generated for process $p$ to be reconstructed in category $c$, the number of events recontructed ($R$) for each category $c$ is:\n", + "\n", + "$$R_c = \\sum_p(\\varepsilon_{c,p} \\cdot T_p) + b_c$$\n", + "\n", + "or in matrix form:\n", + "\n", + "$$\\vec R = \\varepsilon \\cdot\\vec T + \\vec b$$\n", + "\n", + "Knowing $\\varepsilon$, $R$ and $b$ we want to invert the problem and find $T$. This is done with a maximum likelihood fit since the system of equations is generally overconstrained." + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "29\n", - "4\n", - "[1.3e+04 4.6e+04 1.9e+04 6.9e+03 6.4e+02 8.0e+01 7.7e+03 4.1e+03 6.9e+02\n", + "number of categories: 29\n", + "number of processes: 4\n", + "background events in each categories: [1.3e+04 4.6e+04 1.9e+04 6.9e+03 6.4e+02 8.0e+01 7.7e+03 4.1e+03 6.9e+02\n", " 6.1e+01 2.8e+02 3.5e+01 6.9e+02 3.2e+02 4.7e+02 1.1e+02 6.1e+02 9.8e+00\n", " 6.5e+00 9.5e+01 5.3e+00 2.6e+00 5.5e+01 3.3e+01 8.2e+00 1.4e+00 4.7e+00\n", " 4.9e+00 2.2e+00]\n", - "[8109.85 638.401 361.947 106.267]\n" + "number of true signal events for each process: %s [8109.85 638.401 361.947 106.267]\n" ] } ], "source": [ - "print(NCATEGORIES) # number of reco-categories\n", - "print(NPROCESS) # number of truth-processes\n", - "print(EXPECTED_BKG_CAT) # number of background events selected in the reco-categories\n", - "print(NTRUE) # number of signal events at truth level" + "print(\"number of categories: %s\" % NCATEGORIES)\n", + "print(\"number of processes: %s\" % NPROCESS)\n", + "print(\"background events in each categories: %s\" % EXPECTED_BKG_CAT)\n", + "print(\"number of true signal events for each process: %s\", NTRUE)" ] }, { @@ -269,43 +279,44 @@ " EDM= unknown STRATEGY= 1 NO ERROR MATRIX \n", " EXT PARAMETER CURRENT GUESS STEP FIRST \n", " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", - " 1 nsignal_gen_proc0 8.10985e+03 6.00000e+03 2.20655e-01 9.20855e-06\n", - " 2 nsignal_gen_proc1 6.38401e+02 5.31920e+03 2.39508e-01 -1.39042e-04\n", - " 3 nsignal_gen_proc2 3.61947e+02 5.18097e+03 2.35730e-01 -1.68083e-04\n", + " 1 nsignal_gen_proc0 8.10985e+03 6.00000e+03 2.20655e-01 9.20848e-06\n", + " 2 nsignal_gen_proc1 6.38401e+02 5.31920e+03 2.39508e-01 -1.37915e-04\n", + " 3 nsignal_gen_proc2 3.61947e+02 5.18097e+03 2.35730e-01 -1.66678e-04\n", " 4 nsignal_gen_proc3 1.06267e+02 5.05313e+03 2.32220e-01 -9.07401e-03\n", " ERR DEF= 0.5\n", " MIGRAD FAILS TO FIND IMPROVEMENT\n", " COVARIANCE MATRIX CALCULATED SUCCESSFULLY\n", " FCN=101.271 FROM HESSE STATUS=OK 31 CALLS 55 TOTAL\n", - " EDM=1.59862e-13 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " EDM=1.65371e-13 STRATEGY= 1 ERROR MATRIX ACCURATE \n", " EXT PARAMETER STEP FIRST \n", " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", - " 1 nsignal_gen_proc0 8.10985e+03 8.89134e+02 2.20655e-04 -2.61316e-06\n", - " 2 nsignal_gen_proc1 6.38401e+02 1.88182e+02 5.50855e-05 -3.68264e-06\n", - " 3 nsignal_gen_proc2 3.61947e+02 1.93057e+02 5.73194e-05 -5.02666e-06\n", - " 4 nsignal_gen_proc3 1.06267e+02 3.43679e+01 2.32220e-05 -3.68491e-04\n", + " 1 nsignal_gen_proc0 8.10985e+03 8.89134e+02 2.20655e-04 -1.78960e-06\n", + " 2 nsignal_gen_proc1 6.38401e+02 1.88182e+02 5.50855e-05 -1.15832e-05\n", + " 3 nsignal_gen_proc2 3.61947e+02 1.93057e+02 5.73194e-05 -2.21148e-05\n", + " 4 nsignal_gen_proc3 1.06267e+02 3.43679e+01 2.32220e-05 -3.66924e-04\n", " ERR DEF= 0.5\n", + " MIGRAD FAILS TO FIND IMPROVEMENT\n", " MIGRAD MINIMIZATION HAS CONVERGED.\n", - " FCN=101.271 FROM MIGRAD STATUS=CONVERGED 63 CALLS 64 TOTAL\n", - " EDM=2.70926e-12 STRATEGY= 1 ERROR MATRIX UNCERTAINTY 0.9 per cent\n", + " FCN=101.271 FROM MIGRAD STATUS=CONVERGED 55 CALLS 56 TOTAL\n", + " EDM=1.65371e-13 STRATEGY= 1 ERROR MATRIX ACCURATE \n", " EXT PARAMETER STEP FIRST \n", " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", - " 1 nsignal_gen_proc0 8.10985e+03 8.76277e+02 2.23140e-09 4.10803e-06\n", - " 2 nsignal_gen_proc1 6.38401e+02 1.87357e+02 3.45855e-11 -1.89420e-05\n", - " 3 nsignal_gen_proc2 3.61947e+02 1.92903e+02 -3.30381e-10 -2.17203e-05\n", - " 4 nsignal_gen_proc3 1.06267e+02 1.84776e+01 8.55996e-10 -1.52181e-03\n", + " 1 nsignal_gen_proc0 8.10985e+03 8.89134e+02 -0.00000e+00 -1.78960e-06\n", + " 2 nsignal_gen_proc1 6.38401e+02 1.88182e+02 0.00000e+00 -1.15832e-05\n", + " 3 nsignal_gen_proc2 3.61947e+02 1.93057e+02 0.00000e+00 -2.21148e-05\n", + " 4 nsignal_gen_proc3 1.06267e+02 3.43679e+01 0.00000e+00 -3.66924e-04\n", " ERR DEF= 0.5\n", " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 4 ERR DEF=0.5\n", - " 7.681e+05 -4.030e+04 -3.639e+04 3.497e+03 \n", - " -4.030e+04 3.510e+04 -1.079e+03 -6.466e+02 \n", - " -3.639e+04 -1.079e+03 3.721e+04 -5.463e+02 \n", - " 3.497e+03 -6.466e+02 -5.463e+02 -3.414e+02 \n", + " 7.908e+05 -4.266e+04 -3.669e+04 8.644e+01 \n", + " -4.266e+04 3.541e+04 -1.107e+03 -3.688e+01 \n", + " -3.669e+04 -1.107e+03 3.727e+04 -7.370e+02 \n", + " 8.644e+01 -3.688e+01 -7.370e+02 1.181e+03 \n", " PARAMETER CORRELATION COEFFICIENTS \n", " NO. GLOBAL 1 2 3 4\n", - " 1 0.00000 1.000 -0.245 -0.215 0.216\n", - " 2 0.00000 -0.245 1.000 -0.030 -0.187\n", - " 3 0.00000 -0.215 -0.030 1.000 -0.153\n", - " 4 0.00000 0.216 -0.187 -0.153 -1.000\n", + " 1 0.33860 1.000 -0.255 -0.214 0.003\n", + " 2 0.26978 -0.255 1.000 -0.030 -0.006\n", + " 3 0.25633 -0.214 -0.030 1.000 -0.111\n", + " 4 0.11416 0.003 -0.006 -0.111 1.000\n", " **********\n", " ** 7 **SET ERR 0.5\n", " **********\n", @@ -316,26 +327,26 @@ " ** 9 **HESSE 2000\n", " **********\n", " COVARIANCE MATRIX CALCULATED SUCCESSFULLY\n", - " FCN=101.271 FROM HESSE STATUS=OK 31 CALLS 95 TOTAL\n", - " EDM=6.17926e-13 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " FCN=101.271 FROM HESSE STATUS=OK 31 CALLS 87 TOTAL\n", + " EDM=1.25758e-11 STRATEGY= 1 ERROR MATRIX ACCURATE \n", " EXT PARAMETER INTERNAL INTERNAL \n", " NO. NAME VALUE ERROR STEP SIZE VALUE \n", - " 1 nsignal_gen_proc0 8.10985e+03 8.89137e+02 8.82619e-05 -4.07525e-01\n", - " 2 nsignal_gen_proc1 6.38401e+02 1.88182e+02 2.20342e-05 -7.01529e-01\n", - " 3 nsignal_gen_proc2 3.61947e+02 1.93059e+02 2.29278e-05 -7.13656e-01\n", - " 4 nsignal_gen_proc3 1.06267e+02 3.43682e+01 1.05921e-05 -7.24985e-01\n", + " 1 nsignal_gen_proc0 8.10985e+03 8.90688e+02 8.82619e-06 -4.07525e-01\n", + " 2 nsignal_gen_proc1 6.38401e+02 1.88325e+02 2.20342e-06 -7.01529e-01\n", + " 3 nsignal_gen_proc2 3.61947e+02 1.93309e+02 2.29278e-06 -7.13656e-01\n", + " 4 nsignal_gen_proc3 1.06267e+02 3.43698e+01 4.64440e-06 -7.24985e-01\n", " ERR DEF= 0.5\n", " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 4 ERR DEF=0.5\n", - " 7.908e+05 -4.267e+04 -3.669e+04 8.658e+01 \n", - " -4.267e+04 3.541e+04 -1.107e+03 -3.686e+01 \n", - " -3.669e+04 -1.107e+03 3.727e+04 -7.376e+02 \n", - " 8.658e+01 -3.686e+01 -7.376e+02 1.181e+03 \n", + " 7.936e+05 -4.300e+04 -3.719e+04 9.204e+01 \n", + " -4.300e+04 3.547e+04 -1.110e+03 -3.723e+01 \n", + " -3.719e+04 -1.110e+03 3.737e+04 -7.403e+02 \n", + " 9.204e+01 -3.723e+01 -7.403e+02 1.181e+03 \n", " PARAMETER CORRELATION COEFFICIENTS \n", " NO. GLOBAL 1 2 3 4\n", - " 1 0.33861 1.000 -0.255 -0.214 0.003\n", - " 2 0.26979 -0.255 1.000 -0.030 -0.006\n", - " 3 0.25637 -0.214 -0.030 1.000 -0.111\n", - " 4 0.11425 0.003 -0.006 -0.111 1.000\n" + " 1 0.34111 1.000 -0.256 -0.216 0.003\n", + " 2 0.27135 -0.256 1.000 -0.030 -0.006\n", + " 3 0.25864 -0.216 -0.030 1.000 -0.111\n", + " 4 0.11455 0.003 -0.006 -0.111 1.000\n" ] } ], @@ -354,13 +365,13 @@ "output_type": "stream", "text": [ "\n", - " RooFitResult: minimized FCN value: 101.271, estimated distance to minimum: 6.17926e-13\n", + " RooFitResult: minimized FCN value: 101.271, estimated distance to minimum: 1.25758e-11\n", " covariance matrix quality: Full, accurate covariance matrix\n", " Status : MINIMIZE=0 HESSE=0 \n", "\n", " Floating Parameter FinalValue +/- Error \n", " -------------------- --------------------------\n", - " nsignal_gen_proc0 8.1099e+03 +/- 8.89e+02\n", + " nsignal_gen_proc0 8.1098e+03 +/- 8.91e+02\n", " nsignal_gen_proc1 6.3840e+02 +/- 1.88e+02\n", " nsignal_gen_proc2 3.6195e+02 +/- 1.93e+02\n", " nsignal_gen_proc3 1.0627e+02 +/- 3.44e+01\n", @@ -380,7 +391,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArgAAAHYCAIAAAApvgy/AAAABmJLR0QAAAAAAAD5Q7t/AAAgAElEQVR4nO3dTbLrxmE2YOCrTFU3msepLEQuAGN7HbZjbSDKhMAo3kDilNchjQmWtA6XB5rHWgEz6O92+gJsHPIckACbzzNQnQvipwFQxMv+Y30+nysAgEv+39YFAAD2S1AAALIEBQAgS1AAALIEBa7Vtm1d13VdX79JfUnbtm3b9n0/juOdijqOY+7Q8+P2fV/X9f0Kc41wbfu+v/jqOI6xeOnfqwjXKnfoBwjnvtXRy7bwbokvrf6OokBnuE58zxwOh1s3ybl+Vzc5Ho/XH7dpmqqqjsfjrYe4dZOcWKqmaS4eKP6vejgccqu9W9j/uvu8iQ+iewhvlVT6dk3fVOH9f6f/EymDGgWukn7jHIbhpm3nD9Tj8Rg+noZhuOu3mfsdt+/7rus+Xvi4h/P5vMkXu7Ztm6Zp2/bxh+ZO+r4P/5M2TRMTQ9d1mxaKJyYocJXwuRM/dG56pM0fQm3bxj08stJ7q+O+KcSXix7wCB/HcVdXgw8K/7cej8dwZ8+fqw3EQd7nH7YuAE8gfbiO43g6nVbpYXA4HHKVE6HdNPRmeLNUt378heOeTqfl1dIT/OAn7DWnsyx+0A/DcHEnb16Nd1yusMk16y/vPLaFf+QKvO/Q6WrXFODdb6qPFGy+zjXb5s4oZL5JLVHoiRLf8+Gl+KY6nU4yBEse0sDBc0ubxtPWzTctrxk+pyat4/O21Xnr6bwLwmQny4WMh0iLMWkfmf+fEleYH32hs8L8dNKiLp9FeqHiRUgPFzdZvmLLZbjYR2GySdM0k9XCRbu45qTw8ys5WSe9FzfJFXKyt+V3VDyvm25rTm5Xy0dML8i8bmlejOUzyvU5mOwtrhOKceuZ8lK8P3jb/CPmyo/R5WdA7jMuLAzmn6Tpx2u6Tnqg5aAwCSjzoJB+/h4Oh1iquE5asIVeYJPV5qeT7vxwOOQu6aQb2rycYf+xB8bFok4uaSz2PChM7kL66JpctPhMOh6PF2/W5EourJO7hrde28necucyP/3q88M7vYy3liotwzVHnLyU2za96ZMbOt//fJP0UqTFiC+t1S2XUgkKvGH+0L1YE3BR7tM2fhZfTAAXv9xPYsrk8Xzxs3h+6IuP0klQWK7niEveHCtx5el8ZNBBfFKmCyfPg3kZJhdnUoCLl27+3ffiM+zinnO7mpzF+8794tFvKsDFr/XnzNvsylJVmSqN5SPO32ML2y6sk7uehzsMmeFFCAq8YV6TeX3rQ7Vo8imcyx+HKxo+cp/+OfMv0JMgkjuXXLyYy30uT5Z/PChMyhD2PwkKkw3D9+aLBViuuJ7XKFxcLe75YjXJpEhXvpdSuWs7qQnI3aP0HHPvqMllvNLFN/Zkee6IF+/mZPk1lz13PQUF3s2oB94QOkClfZ3i3x/szzgZoxgONO9+Hw4XXg3rH2ZttNd3xQrVywuz0CxsuLzCxV0tn84qrjn3yYxSC3365rc7mF/zNw8dpre62NXug3K9LCc7z51LWHK/wajzcwxX75oj5q582Db3/0j4NH9HUeEaggJL4kdb13XpFIdh4ZUf+hcjavj4m4/tzn2sT8rzZoFzhw4dxZd3Mu9QdrFgy3JR4MHdy+P313gHr7lrVxbyygERcU7Puq5vnYTjg0evLk0PumIZrvRmUW96YxuhwIMJCixZfqh85Gtx3HPZ08du/pnetu35y16TwzA8bM7muq67rgvvk9jj8gHHTTUZ296ai2F0Rbn/rTZ/Q/KMBAWWhI/4iy3xYYWPPG8uVubPP+Bu+i61yufgxQD0vkCzkxgU5r04f+43UL01N+UqxY6D9WNdzrwl4iOuLOSY8cg5pt4s6k2XZXlvuQhy/awYMCEokBU/SS9+uNzaZv+m3A7DkiaZWm5edbxWMRY+RnMN3jm504nz4byjeLcK1f7pEzH8c+HeLd+Fm6TdStaV62Rw8dl/cbU2maNzdbmrd9PUVVF4t6dTJM3XCU0q6VHml+LWNzD8nxU6RFKo8A7Jdfy+ZuzD8grzgd0X1w8Lj4uzOEx6g18/LuN8/+GRy6fz8VEPk4Vpd/1cGdLCf2R45PKIhoXiVR8b9XDOvA0mH2sXBxyeZ0Mz3ryMt5Yqd/XSf+aGbEyWrzXi1JAHPkJQIOvNT/CwwsKH6fIe5p+M8Xv2whw+6YQzYZjfZFDc+WNBIX0oTvafPpZiylnICteczl2Dwjl5dOUu17wAuWJXNwaF9LpNDl1dMR512eRtkJtwKT1cutqb8fSDQWFesPmES7nN4xtvvu05f3fSdeLCyX4W3quwQFDgsty3sdT8CT2x/Gr8jJ4/gFO5qQgmjvmZf5bNn3kXO9wdL01X8Obn75unc++gcM6Mmluu0pgUu/n8I4Rxt9cEhYuHTuNC2Nv1d2piXsiL5zIvwzyoXXMZrxHP8c0jXrzjF9948zLM31TXrCMl8G712ehbdib0NQt/L4z4T7tQ3KPlNRYjt/+4wnK3uCtP567eUYbJ6YdfLj4cDrf2Abx4GcNOPt6dcLLzcRy7rmuaZt5DNi65ax/GMHI4fKjGA737ii1su9Y6cJWtkwqwI+Eb//zb55t9Mh4pFHL+Nfp91QAr8qFKkdQoAP8nfCmvPn8tXli4rfDd/Xg8prUj6Rf6DUu1n6sEqzA8Evg/bduGyoO6rtvPQkq42IK+7qHnsyheVH2e2LjruljIdPlWpYIiqVEApkKPhPjPpmnWnStpFWHSpDg71h4KqUaBIgkKAECWpgcAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIEtQAACyBAUAIOsfti7Ayuq63roIALy08/m8dRHWVFpQqIq7QwA8kfK+r2p6AACyCqxRyKU5NQ0AcKsCg4JAAABr0fQAAGQJCgBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGQVOI+CCZcAYC0FBgWBAADWoukBAMgSFACALEEBAMgqsI8CryN2XNUxBeBO1CjwrNLhLbmhLgB8kKDAU1KXAPAYggJPTEoAuLcC+yiYcKl4F29xXdduMcDqCgwKnhYvIt7o8/msjwLAnWh6AACytg8K4zj2fd+27TiOk5fC8r7v55uE5fNNeGXqFQBWt3FQ6Pu+67rwvO+6rm3b+FJd18MwVFU1DEP6AAibVFU1jmPclhenvQngTjbu/1XX9eFwCHUG4cF/PB5DbcEwDLFs6Wp1XYd1qqpq2/Z0OqWnoEfbKwjBcXKjLy4EeLDyHkPbNz3EWoS0OmEYhqZp4j+bpgk1ByErxDXnrRIUT/sCwCNtHBSapgnNB6HbQZXJDaHmoKqqcRzTABHW0frwggoL7AC7tfHwyHEc67oOfQ6qqjoej/GlNCjc5B3fOD11AOCijWsU6rpumuZ8Pp/P58PhsErnxPPt1jgVdkHDBMC6tgwKIRPEZBA6HMRuBxcTQ2yDWFiH1yTwAdzD9p0ZU7H/Qey9GEy6JqTLqw80UgAAy3Y6PDL8HcqWLq9mQyUnkaK8cSlMLAyDNEIS2Fx5j6GNzyeEgPjPmACqL1sZ0uWTTeaD6Qu7Q6SWf11aUAA2V95jaBfnk2tBWGhZyL1U3h0itRwFlmMEwAOU9xgq7nyKu0Ok3qwzUKkAbKu8x9C+OjMCALuy8YRL95AbSV9YxAOABygwKAgEALAWTQ8AQJagAABkCQoAQJagQIH8NBTAWgQFiqIrK8C6BAUAIEtQAACyCpxHwYRLALCWAoOCQFAqXRQBHk/TA09GEAR4JEEBAMgSFACALEGBMunQALAKQYHS6MQAsCJBAQDIKnB4pHkUAGAtBQYFgQAA1qLpAQDIEhQAgCxBAQDIEhQAgCxBAQDIEhQAgCxBgWKZxRng4wqcR8GES5zPZykBYBUFBgWBAADWoukBAMgSFACArC2bHsZx7Pt+srBt27iw7/txHNMl6YbtZw8oKgC8pn3VKJxOp3Ecw991XQ/DUFXVMAxpx7S+77uuq6pqHMeu6+L6AMDq6l11/avr/1+evu+HYYhlq+v6cDiEeoW6ro/HY6hIaNv2dDqlpxD3QHlCXrzy/t60MsBaynsM7ahGoW3bw+EQ/h6GoWma+FLTNKHmIGSF2Nwwb7kAAFa0l6DQ9/3pdEof/Gnng1BzUFXVOI5pgAjraH0AgDvZyzwKwzAcj8d0ybt7Kb5jpp3CqokAYC27CAqTBoUP8tQHgLXsoulhGIbYOyG62KAQ2yAW1gEA1rJ9UEh7KUax92JcJ+2aMNnWVAoAcCd7CQoToW9jXCH2c0z/W80GRwAA69p+uGdd15P6gyBtZYiTKFSf51mKq03KX94AViLzKAD7V95jaNfns9CykHupvDtEJCgA+1feY6i48ynuDhEJCsD+lfcY2r6PAgCwW7uYR2FduQmXCot4APAABQYFgYCovDpAgAfT9ECZ5AOAVQgKAECWoAAAZAkKAECWoAAAZAkKAEBWgcMjzaMAAGspMCgIBACwFk0PAECWoAAAZAkKAECWoEAJTqfT1kUAKJOgwBP7+eef//3f//3rr79u2/brr7/+7rvvfv75560LBVAUQYFn9fPPP//+97//n//5n7///e9VVf3973//5Zdffve738kKACsSFHhW//Vf//XP//zP//3f/x2X/PnPf/6Xf/mX//zP/9ywVACFqQubdSA321JlfoXnF25uvI9ff/11qEuY+PTpU1g+WR/gAeq6tAdrgTUK54yty8Wafvnll4spYfklAG5VYFDgFXz69Okf//Efb30JgFsVOIUzL+IPf/jDL7/88uc//zld+Mc//vGrr77aqkgA5VGjwLP69ttv//a3v/3rv/5rXPLHP/7xr3/967fffrthqQAKIyjwrP7pn/7pL3/5y6dPnz59+lRV1adPn7766qu//OUvv/rVr7YuGkA5SuucWV53U6KFUQzjOLZte/36AHdS3mOouPMp7g4R3frgFxSAxyvvMaTpAQDIKnDUQ27OpcIiHgA8QIFBQSAAgLVoegAAsnYRFPq+b9u27/srl4cu7n3fj+P4kAKyIws/5wHA6rYPCnVdh+f9MAzpCLe6rodhCMvTZ0Pf913XVVU1jmPXdbLC69CoBPB4G4/iCMkgPuzruj4ej6G2YBiGWLa6rg+HQ6haiOuEzU+nU3oK5Y1LIXXTiEfDI4HHK+8xtPH5pE/9yfKmaWKAiHliEiBCpYKg8DoEBWDnynsMbdn0EHJAqD+Y90VI00OoOQibNE0zWUfrAwDcyb76KKR9EebVDNfv8FZrnAcAFGj7oHA4HMZxHMcx1NXMxzjc6ny7FU4DAEq0fVBIk0HaL+Fig0Jsg1hYBwBYy5ZBYd7D4HQ6hYVpYqhmXRPS5dUHGikAgGU7Gh4ZhjCEQRDpcIZ0eTUbKjmJFOV1NyVl1AOwc+U9hrY/n7QvYUwA1ZetDOnykBviJpPyl3eHSAkKwM6V9xjaxfnkWhAWWhZyL5V3h0gJCsDOlfcYKu58irtDpAQFYOfKewxtP+oBANitf9i6AOvLTaBUWMQDgAcoMCgIBACwFk0PAECWoMDz8fMcAA8jKPBMtCsBPJigAABkCQoAQJagAABkCQoAQFaB8yiYcAkA1lJgUBAIAGAtmh4AgCxBAQDIEhQAgCxBAQDIEhQAgCxBAQDIKnB4pHkUAGAtBQYFgeAV1HXtRgM8gKYHnox8APBIggIAkCUoAABZggIAkCUoAABZggIAkCUoAABZBc6jYMIlAFhLgUFBIHgR5lwCeABNDzwf+QDgYQQFACBr46AwjmP7pfTVvu/btu37/uJWfd+P4/iokvJkcl1VALjJ9kHhdDpdfKmu62EYqqoahiH90O/7vuu6sG3XdbICCzRSAHzQxt3BQhXC/GHf9/0wDLFsdV0fDodQtVDX9fF4DBu2bXs6ndJT0MHtRYTsuHCv31wB4B7KewxtXKNwOp0mzQ3BMAxN08R/Nk0TwkTICnGTeasEALCi7TszjuNY13Vd123bplULaYAINQdh5TRA5CokAIBVbB8Uqqo6Ho/H47GqqtD5ILhY03CN+narnAUAlGfjCZfShpxQtdD3/QcbFAprHGJBeW2BAHuzixqFKPZFqDINCrENYmEdXoF8APAYWwaFMB1CuiSGgDQxVLOuCeny6gONFADAG86bqqrqcDiEvw+HQ1VVx+PxfD6HLgthefg7LJ9sUlVV0zSTHd6/1OzCwht4J29v4AWV98mzcRNvmC8h/jNOllB92cqQLg/zLMVNJuXXaP06FmZKMIkCsJXyHkO7OJ9cC8JCy0LupfLuEDmCArBD5T2Gijuf4u4QOYICsEPlPYb2NeoBANiVjedRuIfcBEqFRTyC8sI7wK4UGBQ8Nl7E+Xw2qybAvWl6AACyBAUAIEtQ4OlpgAC4H0GBJ7YwNhKAVQgKlEmfVoBVCAqUQC0CwJ0UODzSPAovxSBJgLsqMCgIBK9MaABYl6YHCpFGBGERYC2CAk8vxgLVCQCrExQojeoEgBUJCpQghgMpAWBdBXZm5DWJCAD3oEYBAMgSFACArAKbHky4BABrKTAoCAQAsBZNDwBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGQJCgBAVoHzKJhwCQDWUmBQEAgAYC2aHgCArB0FhbZtJ0v6vm/btu/7yfJxHMPycRwfUjQAeFF7CQpt255Op/TBX9f1MAxVVQ3DkHY76Pu+67qqqsZx7LpOVgCA+9lFUBjH8XQ6pUtCLcL5fB7HMfQ5iPUKwzAcj8dxHMdxbJomhAYA4B52ERS6rjscDumSYRiapon/bJom1ByEuBAbKeatEgDAirYPCm3bHg6H+SM/7bIQGiaqqgq1CJN1tD4AwJ1sPDyy7/tJ14Ro3rfxSrl5FBYYUQkAF20ZFMZxHIZh9Ye0pz4ArGXLpofY4SCoqqrruliRkKtmSLs9anQAgLvaskZhMhHC6XRqmiakh9h7MZh0TUiXVx9opAAAltX7qaiv6/p4PMb+iV3XhbKFv+NLdV3Hzo91XU8iRV3v6IwAeDXlPYZ2+lsPbds2TRO7JR4Oh1htcDweu64LczFVWh8A4J52HXwWWhZyL5UX5QB4IuU9hoo7n+LuEABPpLzH0PYTLgEAu7XTPgofkZtwqbCIBwAPUGBQEAgAYC2aHgCALEEBAMgSFACALEEBAMgSFACALEEBAMgSFACArALnUTDhEgCspcCgIBAAwFo0PQAAWYICAJAlKAAAWYICAJAlKAAAWYICAJBV4PBI8ygAwFoKDAoCAQCsRdMDAJAlKAAAWYICAJAlKAAAWYICAJAlKAAAWYICAJBV4DwKJlwCgLUUGBQEAgBYi6YHACBLUAAAsrYPCuM49n3ftu04jpOXwvK+7+ebhOXzTQCAFW0cFNq27bouPO+7rmvbNr5U1/UwDFVVDcOQ9k/s+77ruqqqxnGM2wIA91Bv2/Wvruvj8RjyQXjwh/L0fT8MQyxbXdeHwyFULaSbtG17Op3SU6jrjc8IgFdW3mNoyxqFUBkQaxFiXKiqahiGpmnimk3ThOUhK8RN5q0SAMCKtgwKbdumsStWEqT/jH+fTqeqqsZxTANEmi0AgNXtYh6FmAOOx2O68H17y024tKCwaiIAWMsugsL4Wdd1sf/Bu3nqA8Bath8eGcRhkLEd4WKDQqx7WFgHAFjLlkGh7/tcM0HsvRhMuiaky6sPNFIAAMs2DgpVMnIhfer3fR9rDsZxPJ1O6cpxk8ngCABgXRsP9wzzJcR/xskSqi9bGdLloStD3GRS/vIGsALwRMp7DO3ifHItCAstC7mXyrtDADyR8h5DxZ1PcXcIgCdS3mNoL6MeAIAd2sU8CuvKjaQoLOIBwAMUGBQEAgBYi6YHACBLUAAAsgQFACBLUAAAsgQFACBLUAAAsgocHmkeBQBYS4FBQSAAgLVoegAAsgQFACBLUAAAsgQFACBLUAAAsgQFACBLUAAAsgqcR8GESwCwlgKDgkAAAGvR9AAAZAkKAECWoAAAZAkKAECWoAAAZAkKAECWoAAAZBU4j4IJlwBgLQUGBYEAANai6QEAyNo+KIzj2Pd927Z9309eyi0fxzEsH8fxIWUEgBdVb1tR3/f9MAxN01RVdTqdqqThIHQ1aJpmsnyyyfF4bNs27rCuNz4jAF5ZeY+hjWsUhmE4HA7jOI7jGK5sqD8I/z2fz5PlYZPj8Rg2aZqm67qNyg4A5ds4+EySV6gbGMexruumaWLLQlweqhPiJuM4dl2X7qG8KAfAEynvMbRxjcLkap5Op9iOkDYotG0bGiBCLUK6PCy8dzkB4DVt35kxCLUIVdLEkAaFm9S3W+kkAKA0uwgKbdt2Xdc0zSrVNefbffygAFCkjYNCrEgI/RMnL83Xj20QC+sAAGvZeGbGUJEwf95PFk66JqTLqw80UgAAy7bsnBnGLBwOh8mTvm3bdDhD+DvOl1DX9eFwCF0ZJoMjqhK7mwLwRMp7DG15PmGs42RhfPCnrQwxGVSfc0Ncf1L+8u4QAE+kvMfQrs9noWUh91J5dwiAJ1LeY6i48ynuDgHwRMp7DO1ieCQAsE8bj3q4h9wESoVFPAB4gAKDgkAAAGvR9AAAZAkKAECWoAAAZAkKAECWoAAAZAkKAECWoAAAZBU4j4IJlwBgLQUGBYEAANai6QEAyBIUAIAsQQEAyBIUAIAsQQEAyBIUAICsAodHmkcBANZSYFAQCABgLZoeAIAsQQEAyBIUAIAsQQEAyBIUAIAsQQEAyBIUAICsAudRMOESAKylwKAgEADAWjQ9AABZggIAkLWXoND3/cWFbdvOXxrHMSwfx/H+RQOA17WLoDCO4zAMk6d+XdfDMFRVNQxD2j+x7/uu68JWXdfJCgBwPxsHhVA3EB78qVCLcD6fx3EMnRNjvcIwDMfjcRzHcRybpplvCwCsZfsahbZtD4fDZOEwDE3TxH82TRNqDkJcaNs2LL/YYAEArGXjoBC6Glx83sc0EP4+nU5VVYVahMk6Wh8A4E72O49CGhRukptwaYGpFwDgov0GhXfz1AeAtWzfRyHnYoNCbINYWAcAWMtOg0LsvRhMuiaky6sPNFIAAMt2GhT6vo81B+M4nk6n0OEx/W81GxwBAKxrp30U2rZtmiZ2SzwcDrHa4Hg8dl0X5mKqtD4AwD3Ve+76t9CykHuprnd9RgCUrbzHUHHnU9wdAuCJlPcY2mkfBQBgD3baR+EjchMuFRbxAOABCgwKAgEArEXTAwCQJSgAAFmCAgCQJSgAAFmCAgCQJSgAAFkFDo80jwIArKXAoCAQAMBaND0AAFmCAgCQJSgAAFmCAgCQJSgAAFmCAgCQJSgAAFkFzqNgwiUAWEuBQUEgAIC1aHoAALIEBQAgS1AAALIEBQAgS1B4CbmRIC/OZbnIZZlzTS5yWV6EoAAAZAkKAEBWgfMomHAJANZSYFAQCABgLZoeAICsZw0K33333a9//esffvhhrR2+r/vuuzv9Pvhw7/Pgs3v3hmVflsffhQcfzmVZa6tNNnzk4Z7lPVae5wsKP/zwQ13XP/30U1VVv/3tb7/77rutSwQAxaqfrkW/rutvvvnmxx9/rKrqu++++9Of/pSeQl2/84zet6HD7WFDh9vDhg73vId794YOt+6Gu/V8NQpVVf3bv/1b+OM//uM/qqpSqQAAd/JkQSF0SvjNb36zdUEA4CWUMDwy9FeInqXDi8OtuKHD7WFDh3vew717Q4d7BSUEhVRhLUMAsK0na3q46Jtvvtm6CABQpicLCqF3wmT6BEEBAO7k+UZx/PrXv66qKjc8EgBY0dPUKPR9H/748ccff/rpp7qu67r+05/+9P3338eXonEc27bt+34cx/l+2rbNLZ/vqgC5Uy7MxXuXu62v8A4ZxzFX5pe9LPGaXH8ixV+TVNu2kyUve1nCCabSV1/uspyfwfF4rKrqeDzGJd9///33339fVVXTNJMTORwOYXl4KW4VdhKXHw6HuEnYw3xXz27hlAszf4ec87f1Fd4hk3NMy/yylyWUM55I0zTxpZe9JqnJOZ5f+7Kk5xjEl17wsuy3ZMHxeIwXMX0Hh1sS/5le/XTNsG1cHm92uHNv7urZpac8Oc1ieIdcNP88Cv985csy/+wOf7/yNYnCWaTn++KXZRIOote8LHt/chyPx8PhEC7oJOqmdzHe1MmlT+/KfA/hrkzeELn3xzPKnXJJvEMumoTCWOaXvSzpGQXxvF72mqTCKaTn9eKXJfdp+ZqXZe99FELjzcX2m7TRqG3b0+lUVdU4jvH7ZVxnHMfQMjRvgauq6nQ6XdzVs1s45ZJ4h1x0/rKHb3oKr3lZ2rZNr0ko+Ytfk6ht28PhMP+f6MUvyziOoTPcpG/BC16WvQeFBR98BDZNU3z/vrmXOmXvkOrzh12VdPZ88cvStm1d16fTKVa2V699Tfq+P51Ob0btd3jqyxIcj8fwPum6Li58wcuyi5kZY+ya2HtHUNi38B3lGT+Y7mf8rOu64/FYfJXbsnEch2GY1D9RfVknF9J2rubyFTxxjcLFz75J7c3C5+Ok2udFvNQpv/I7JFYkHI/HyTm+8mUJ4mi0eJove03CdWg/q6qq67p4Li97WebStP2Cl2UXNQrxPXq9yZekSftQurxKno5hkGt63Ot39XRiI9n8lF/Bi79Duq67WJHwspel7/vcV+eXvSZVVU1G/If6p5AeXvmyjON48cpUL3tZNu1KeYPqy46jaZ/SyRj66svxKrEfaZOMV0l7qKabXxyO/7zSbrSlDo+MvEOiUMjD4XD80vm1L0t6gvPCz5efX+CaTKQFfvHLkp5jOh7kNS/L0zw55hcxDV/pOJa0j1I1GxAVpXtLd7XbASrvkzvl8niHROHDaGLyseWypOf+stdkYuFcXu2yeLeknu+3HlKT6p1rXlpentvbU1u4SsXzDrnolS/LrSf4jnkkUf4AAAMKSURBVE2e7posePHL4t0SPHdQAADu6olHPQAA9yYoAABZggIAVfX5J4/X3WeYqmjdfe7Kc/xO9McICgBU1bumtHlxbdsOw1BV1TAMYYqzIgkKAFRVMmcl1wg/k3E+n8dxDMMCSr16ggJAseq6Hj//CmLaCpAujLUIadPDZKv4dfmaHYZ1ri9k7ljV5x/xmuwzV4acEIDiribnOH7+KYfcZcktn8yl2DRNqF0o0LbTOABwP+FzPkzyk04LWH2eLCjO4xlWiNP+TFZIN8zt8OJchNWXsxLlCnnxWGFu2XCsyT4vliEnzr4cD5H+XV2aUTFdbb48rD85tYJnvy3zrAA4zx5m4Uk2mTA4zvAdg8LkmXcxYcR/xm3jwnSe4zeDQu5Y6U4mx8qVIScNGemeJ9dhUpK42ryE4SpVl2ZmXCjG89rFj0IBcCfz/ont5x+KbJrmYr+ESaV67LKX22H1+felgvR3FN+UO1ZoaJiULf660q2dLieHqC5NiTgvSfX5d8nT5aV2RFigjwJAyS4+U8+fvwGH7voff/jVdd11XXiQX/y1kY87HA57HpRxU7eM5yIoALyc8EQP3fU/3gsv5Izz+Rx+oHmVx3nYSZ+oPvCDCGklR+6J3rbtxbqQyfJYq/FMvxP9MYICwGsZxzF8+8+tEAb+xRW6rrtp/zfVT+SOFYNCXG2VNBP/yLXITJok4twS8xJOSn46nYptldi4jwQAd1PN+gOGPybffSedGc9f/s7ypDNj2nOwSjoYTta/2OPvotyxJj/cHI+bK0NOGD0x39W8++Gk0WTSz3H+3EyX7/l3oj/Ir0cCvKJrfuA4tlB0XffmwyL9JeV3/Lp97ljv2NVE2i3xml2976ei99x/4oMEBQC+MHlaT+ren+5Ydy3/KzA8EoAvtG3bNE06Q+IHv1IuV1qscqzcIQr+ov8wahQAuOyRler3O1Ycp8D7CAoAQJbhkQBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGQJCgBAlqAAAGT9L5fph4wqr2jjAAAAAElFTkSuQmCC\n", "text/plain": [ "" ] @@ -463,32 +474,25 @@ "tree.Draw(\"(nsignal_gen_proc0 - {}) / nsignal_gen_proc0_error\".format(NTRUE[0]))\n", "canvas.Draw()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.15" + "pygments_lexer": "ipython3", + "version": "3.7.1" } }, "nbformat": 4, diff --git a/examples/Example2.ipynb b/examples/Example2.ipynb new file mode 100644 index 0000000..5f9533d --- /dev/null +++ b/examples/Example2.ipynb @@ -0,0 +1,470 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example 2\n", + "\n", + "Create a workspace without systematics and with signal strengths interpretation of the number of fitted events." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Welcome to JupyROOT 6.14/08\n" + ] + } + ], + "source": [ + "import countingworkspace\n", + "from countingworkspace import create_workspace, create_variables\n", + "import countingworkspace.utils\n", + "from countingworkspace.examples import NCATEGORIES, NPROCESS, EFFICIENCIES, EXPECTED_BKG_CAT, LUMI, XSECFID_X_BR_PRODUCTION_MODES, NAMES_PROC\n", + "import ROOT\n", + "\n", + "countingworkspace.utils.silence_roofit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the number of generated signal events ($T$) for each process $p$, the number of background events $b$ for each category $c$ and the probability ($\\varepsilon$) for an event generated for process $p$ to be reconstructed in category $c$, the number of events recontructed ($R$) for each category $c$ is:\n", + "\n", + "$$R_c = \\sum_p(\\varepsilon_{c,p} \\cdot T_p) + b_c$$\n", + "\n", + "or in matrix form:\n", + "\n", + "$$\\vec R = \\varepsilon \\cdot\\vec T + \\vec b$$\n", + "\n", + "Knowing $\\varepsilon$, $R$ and $b$ we want to invert the problem and find $T$. This is done with a maximum likelihood fit since the system of equations is generally overconstrained.\n", + "\n", + "This time we want to parametrize $T$ in some way and to fit directly the parameters. The easiest way is with the signal strenghts and the luminosity $L$, e.g.\n", + "\n", + "$$\\vec T = L \\vec \\mu \\circ \\vec \\sigma^{SM}$$\n", + "\n", + "where $\\sigma^{SM}$ is the cross section times Br predicted by the Standard Model. $\\circ$ is the Hadamard produc (element by element). $\\vec \\mu$ are the free parameters in the fit." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of categories: 29\n", + "number of processes: 4\n", + "background events in each categories: [1.3e+04 4.6e+04 1.9e+04 6.9e+03 6.4e+02 8.0e+01 7.7e+03 4.1e+03 6.9e+02\n", + " 6.1e+01 2.8e+02 3.5e+01 6.9e+02 3.2e+02 4.7e+02 1.1e+02 6.1e+02 9.8e+00\n", + " 6.5e+00 9.5e+01 5.3e+00 2.6e+00 5.5e+01 3.3e+01 8.2e+00 1.4e+00 4.7e+00\n", + " 4.9e+00 2.2e+00]\n", + "lumi (1/fb): 79.9\n", + "xsections x Br (fb): [101.5 7.99 4.53 1.33]\n", + "names proc: ['ggF', 'VBF', 'VH', 'TOP']\n" + ] + } + ], + "source": [ + "print(\"number of categories: %s\" % NCATEGORIES)\n", + "print(\"number of processes: %s\" % NPROCESS)\n", + "print(\"background events in each categories: %s\" % EXPECTED_BKG_CAT)\n", + "print(\"lumi (1/fb): %s\" % LUMI)\n", + "print(\"xsections x Br (fb): %s\" % XSECFID_X_BR_PRODUCTION_MODES)\n", + "print(\"names proc: %s\" % NAMES_PROC)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[7.59656034e-02 1.04604628e-02 1.45411863e-02 1.99323973e-04]\n", + " [1.33594250e-01 2.02726463e-02 3.01054468e-02 4.64708281e-04]\n", + " [6.32722516e-02 4.93284896e-02 4.10382246e-02 1.61497714e-03]\n", + " [3.06301561e-02 5.44006917e-02 3.60505886e-02 1.75309571e-03]\n", + " [5.80297648e-03 1.72063389e-02 1.08921484e-02 7.53345470e-04]\n", + " [1.47098772e-03 5.09554732e-03 3.25223363e-03 2.83602730e-04]\n", + " [1.64200334e-02 2.34817187e-02 3.26838551e-02 2.00158007e-02]\n", + " [1.32634439e-02 2.65507197e-02 2.95846158e-02 2.05596601e-02]\n", + " [5.41438547e-03 1.15379354e-02 1.34674271e-02 8.45197096e-03]\n", + " [1.32996028e-03 2.26448816e-03 3.69473056e-03 2.83567831e-03]\n", + " [1.58368047e-03 3.77259060e-02 7.13420676e-04 5.79753334e-04]\n", + " [4.11651139e-04 3.59157521e-02 1.52405157e-04 4.01419976e-04]\n", + " [3.02746026e-03 1.23900366e-02 3.90893629e-03 3.89613886e-03]\n", + " [2.46153506e-03 3.04511703e-02 3.04539501e-03 6.76058076e-03]\n", + " [2.55635930e-03 2.54552892e-03 2.21037070e-02 4.43348558e-03]\n", + " [1.47979591e-03 1.28219234e-03 2.68690187e-02 2.91074073e-03]\n", + " [2.66557615e-03 1.63703998e-02 1.22851974e-02 1.48447097e-02]\n", + " [2.57041110e-05 2.15494512e-05 2.94283651e-03 7.85191368e-05]\n", + " [3.60068642e-06 5.38736280e-06 6.29711955e-03 1.23833767e-03]\n", + " [1.40949500e-04 1.69701928e-04 2.41122867e-02 1.13397840e-02]\n", + " [0.00000000e+00 2.69368141e-06 6.37652820e-03 4.38890222e-03]\n", + " [0.00000000e+00 0.00000000e+00 4.47888247e-03 2.02333534e-04]\n", + " [1.85504850e-04 3.44791219e-04 2.50041794e-03 3.37407495e-02]\n", + " [1.03138116e-04 1.48152478e-04 1.54299080e-03 4.93388464e-02]\n", + " [3.09359056e-05 4.30989025e-05 5.13108171e-04 3.48397110e-02]\n", + " [1.59986725e-05 2.33452389e-05 3.55199467e-04 4.24037678e-02]\n", + " [9.96932259e-07 1.79578760e-06 2.80456654e-04 9.79772256e-03]\n", + " [0.00000000e+00 8.97893801e-07 2.05172909e-04 2.35936513e-02]\n", + " [0.00000000e+00 0.00000000e+00 1.21035334e-04 4.55973537e-02]]\n" + ] + } + ], + "source": [ + "print(EFFICIENCIES) # efficiencies: probability for a particular event for a particular\n", + " # truth-process to be selected in a particulare reco-category" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RooRealVar::xsec_ggF = 101.5 C L(-INF - +INF) \n", + "RooRealVar::xsec_VBF = 7.99 C L(-INF - +INF) \n", + "RooRealVar::xsec_VH = 4.53 C L(-INF - +INF) \n", + "RooRealVar::xsec_TOP = 1.33 C L(-INF - +INF) \n" + ] + } + ], + "source": [ + "# first create the parameters needed for the parametrization. The luminosity\n", + "ws = ROOT.RooWorkspace()\n", + "ws.factory('lumi[%f]' % LUMI)\n", + "# and the cross sections:\n", + "ntrue = create_variables(ws, 'xsec_{proc}', # {proc} is an index, you can call as you prefer\n", + " #nbins=NPROCESS, # this is not necessary\n", + " bins=NAMES_PROC, # the names\n", + " values=XSECFID_X_BR_PRODUCTION_MODES)\n", + "\n", + "for l in ntrue:\n", + " l.Print()\n", + " \n", + "# we have all the ingredients to define the parametrization" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:adding observables for 29 categories\n", + "INFO:root:adding efficiencies for 29 categories and 4 processes\n", + "INFO:root:adding expected events for 29 categories and 4 processes\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1) RooAddition:: nexp_cat0 = 13628\n", + " 2) RooAddition:: nexp_cat1 = 47107.3\n", + " 3) RooAddition:: nexp_cat2 = 19559.6\n", + " 4) RooAddition:: nexp_cat3 = 7196.37\n", + " 5) RooAddition:: nexp_cat4 = 702.068\n", + " 6) RooAddition:: nexp_cat5 = 96.3898\n", + " 7) RooAddition:: nexp_cat6 = 7862.11\n", + " 8) RooAddition:: nexp_cat7 = 4237.41\n", + " 9) RooAddition:: nexp_cat8 = 747.048\n", + " 10) RooAddition:: nexp_cat9 = 74.8701\n", + " 11) RooAddition:: nexp_cat10 = 317.247\n", + " 12) RooAddition:: nexp_cat11 = 61.3649\n", + " 13) RooAddition:: nexp_cat12 = 724.291\n", + " 14) RooAddition:: nexp_cat13 = 361.223\n", + " 15) RooAddition:: nexp_cat14 = 500.828\n", + " 16) RooAddition:: nexp_cat15 = 132.854\n", + " 17) RooAddition:: nexp_cat16 = 648.092\n", + " 18) RooAddition:: nexp_cat17 = 11.0957\n", + " 19) RooAddition:: nexp_cat18 = 8.94346\n", + " 20) RooAddition:: nexp_cat19 = 106.184\n", + " 21) RooAddition:: nexp_cat20 = 8.07608\n", + " 22) RooAddition:: nexp_cat21 = 4.24262\n", + " 23) RooAddition:: nexp_cat22 = 61.2151\n", + " 24) RooAddition:: nexp_cat23 = 39.7326\n", + " 25) RooAddition:: nexp_cat24 = 12.3664\n", + " 26) RooAddition:: nexp_cat25 = 6.17934\n", + " 27) RooAddition:: nexp_cat26 = 5.85192\n", + " 28) RooAddition:: nexp_cat27 = 7.48206\n", + " 29) RooAddition:: nexp_cat28 = 7.0893\n" + ] + } + ], + "source": [ + "# specify which expression you want to use for the number of generated events (mu * lumi * xsection)\n", + "# instead of specifying how many generated events we expect, specify its expression\n", + "create_workspace(NCATEGORIES, NAMES_PROC,\n", + " efficiencies=EFFICIENCIES,\n", + " nexpected_bkg_cat=EXPECTED_BKG_CAT,\n", + " expression_nsignal_gen='prod:nsignal_gen_proc{proc}(mu_{proc}[1, -4, 5], lumi, xsec_{proc})',\n", + " ws=ws)\n", + "# get the pdf and the observables from the ModelConfig\n", + "\n", + "pdf = ws.obj('ModelConfig').GetPdf()\n", + "obs = ws.obj('ModelConfig').GetObservables()\n", + "\n", + "# check the expected yield for each categories\n", + "ws.set('all_exp').Print('V')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Asimov" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataStore CountingAsimovData0 (CountingAsimovData0)\n", + " Contains 1 entries\n", + " Observables: \n", + " 1) nobs_cat0 = 13628 L(0 - 100000) \"nobs_cat0\"\n", + " 2) nobs_cat1 = 47107.3 L(0 - 100000) \"nobs_cat1\"\n", + " 3) nobs_cat2 = 19559.6 L(0 - 100000) \"nobs_cat2\"\n", + " 4) nobs_cat3 = 7196.37 L(0 - 100000) \"nobs_cat3\"\n", + " 5) nobs_cat4 = 702.068 L(0 - 100000) \"nobs_cat4\"\n", + " 6) nobs_cat5 = 96.3898 L(0 - 100000) \"nobs_cat5\"\n", + " 7) nobs_cat6 = 7862.11 L(0 - 100000) \"nobs_cat6\"\n", + " 8) nobs_cat7 = 4237.41 L(0 - 100000) \"nobs_cat7\"\n", + " 9) nobs_cat8 = 747.048 L(0 - 100000) \"nobs_cat8\"\n", + " 10) nobs_cat9 = 74.8701 L(0 - 100000) \"nobs_cat9\"\n", + " 11) nobs_cat10 = 317.247 L(0 - 100000) \"nobs_cat10\"\n", + " 12) nobs_cat11 = 61.3649 L(0 - 100000) \"nobs_cat11\"\n", + " 13) nobs_cat12 = 724.291 L(0 - 100000) \"nobs_cat12\"\n", + " 14) nobs_cat13 = 361.223 L(0 - 100000) \"nobs_cat13\"\n", + " 15) nobs_cat14 = 500.828 L(0 - 100000) \"nobs_cat14\"\n", + " 16) nobs_cat15 = 132.854 L(0 - 100000) \"nobs_cat15\"\n", + " 17) nobs_cat16 = 648.092 L(0 - 100000) \"nobs_cat16\"\n", + " 18) nobs_cat17 = 11.0957 L(0 - 100000) \"nobs_cat17\"\n", + " 19) nobs_cat18 = 8.94346 L(0 - 100000) \"nobs_cat18\"\n", + " 20) nobs_cat19 = 106.184 L(0 - 100000) \"nobs_cat19\"\n", + " 21) nobs_cat20 = 8.07608 L(0 - 100000) \"nobs_cat20\"\n", + " 22) nobs_cat21 = 4.24262 L(0 - 100000) \"nobs_cat21\"\n", + " 23) nobs_cat22 = 61.2151 L(0 - 100000) \"nobs_cat22\"\n", + " 24) nobs_cat23 = 39.7326 L(0 - 100000) \"nobs_cat23\"\n", + " 25) nobs_cat24 = 12.3664 L(0 - 100000) \"nobs_cat24\"\n", + " 26) nobs_cat25 = 6.17934 L(0 - 100000) \"nobs_cat25\"\n", + " 27) nobs_cat26 = 5.85192 L(0 - 100000) \"nobs_cat26\"\n", + " 28) nobs_cat27 = 7.48206 L(0 - 100000) \"nobs_cat27\"\n", + " 29) nobs_cat28 = 7.0893 L(0 - 100000) \"nobs_cat28\"\n" + ] + } + ], + "source": [ + "# generate the Asimov, the values should be equal to the expected ones\n", + "\n", + "data_asimov = ROOT.RooStats.AsymptoticCalculator.GenerateAsimovData(pdf, obs)\n", + "data_asimov.Print('V')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " **********\n", + " ** 1 **SET PRINT 1\n", + " **********\n", + " **********\n", + " ** 2 **SET NOGRAD\n", + " **********\n", + " PARAMETER DEFINITIONS:\n", + " NO. NAME VALUE STEP SIZE LIMITS\n", + " 1 mu_TOP 1.00000e+00 9.00000e-01 -4.00000e+00 5.00000e+00\n", + " 2 mu_VBF 1.00000e+00 9.00000e-01 -4.00000e+00 5.00000e+00\n", + " 3 mu_VH 1.00000e+00 9.00000e-01 -4.00000e+00 5.00000e+00\n", + " 4 mu_ggF 1.00000e+00 9.00000e-01 -4.00000e+00 5.00000e+00\n", + " **********\n", + " ** 3 **SET ERR 0.5\n", + " **********\n", + " **********\n", + " ** 4 **SET PRINT 1\n", + " **********\n", + " **********\n", + " ** 5 **SET STR 1\n", + " **********\n", + " NOW USING STRATEGY 1: TRY TO BALANCE SPEED AGAINST RELIABILITY\n", + " **********\n", + " ** 6 **MIGRAD 2000 1\n", + " **********\n", + " FIRST CALL TO USER FUNCTION AT NEW START POINT, WITH IFLAG=4.\n", + " START MIGRAD MINIMIZATION. STRATEGY 1. CONVERGENCE WHEN EDM .LT. 1.00e-03\n", + " FCN=101.271 FROM MIGRAD STATUS=INITIATE 16 CALLS 17 TOTAL\n", + " EDM= unknown STRATEGY= 1 NO ERROR MATRIX \n", + " EXT PARAMETER CURRENT GUESS STEP FIRST \n", + " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", + " 1 mu_TOP 1.00000e+00 9.00000e-01 2.02684e-01 -4.31020e-05\n", + " 2 mu_VBF 1.00000e+00 9.00000e-01 2.02684e-01 -2.26419e-05\n", + " 3 mu_VH 1.00000e+00 9.00000e-01 2.02684e-01 -1.61189e-05\n", + " 4 mu_ggF 1.00000e+00 9.00000e-01 2.02684e-01 -8.86064e-06\n", + " ERR DEF= 0.5\n", + " MIGRAD MINIMIZATION HAS CONVERGED.\n", + " MIGRAD WILL VERIFY CONVERGENCE AND ERROR MATRIX.\n", + " COVARIANCE MATRIX CALCULATED SUCCESSFULLY\n", + " FCN=101.271 FROM MIGRAD STATUS=CONVERGED 66 CALLS 67 TOTAL\n", + " EDM=2.17224e-11 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " EXT PARAMETER STEP FIRST \n", + " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", + " 1 mu_TOP 1.00000e+00 3.23131e-01 5.00483e-04 5.16872e-05\n", + " 2 mu_VBF 1.00000e+00 2.94557e-01 4.42143e-04 3.02401e-05\n", + " 3 mu_VH 1.00000e+00 5.32127e-01 8.03102e-04 2.31647e-05\n", + " 4 mu_ggF 1.00000e+00 1.09642e-01 1.60720e-04 5.29166e-05\n", + " ERR DEF= 0.5\n", + " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 4 ERR DEF=0.5\n", + " 1.046e-01 -5.433e-04 -1.917e-02 1.004e-04 \n", + " -5.433e-04 8.689e-02 -4.791e-03 -8.239e-03 \n", + " -1.917e-02 -4.791e-03 2.845e-01 -1.250e-02 \n", + " 1.004e-04 -8.239e-03 -1.250e-02 1.202e-02 \n", + " PARAMETER CORRELATION COEFFICIENTS \n", + " NO. GLOBAL 1 2 3 4\n", + " 1 0.11421 1.000 -0.006 -0.111 0.003\n", + " 2 0.26975 -0.006 1.000 -0.030 -0.255\n", + " 3 0.25632 -0.111 -0.030 1.000 -0.214\n", + " 4 0.33856 0.003 -0.255 -0.214 1.000\n", + " **********\n", + " ** 7 **SET ERR 0.5\n", + " **********\n", + " **********\n", + " ** 8 **SET PRINT 1\n", + " **********\n", + " **********\n", + " ** 9 **HESSE 2000\n", + " **********\n", + " COVARIANCE MATRIX CALCULATED SUCCESSFULLY\n", + " FCN=101.271 FROM HESSE STATUS=OK 29 CALLS 96 TOTAL\n", + " EDM=2.46569e-11 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " EXT PARAMETER INTERNAL INTERNAL \n", + " NO. NAME VALUE ERROR STEP SIZE VALUE \n", + " 1 mu_TOP 1.00000e+00 3.22505e-01 2.00193e-05 1.11341e-01\n", + " 2 mu_VBF 1.00000e+00 2.94230e-01 1.76857e-05 1.11341e-01\n", + " 3 mu_VH 1.00000e+00 5.31656e-01 3.21241e-05 1.11341e-01\n", + " 4 mu_ggF 1.00000e+00 1.09629e-01 3.21439e-05 1.11341e-01\n", + " ERR DEF= 0.5\n", + " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 4 ERR DEF=0.5\n", + " 1.042e-01 -4.084e-04 -1.877e-02 7.279e-05 \n", + " -4.084e-04 8.670e-02 -4.651e-03 -8.224e-03 \n", + " -1.877e-02 -4.651e-03 2.840e-01 -1.249e-02 \n", + " 7.279e-05 -8.224e-03 -1.249e-02 1.202e-02 \n", + " PARAMETER CORRELATION COEFFICIENTS \n", + " NO. GLOBAL 1 2 3 4\n", + " 1 0.11211 1.000 -0.004 -0.109 0.002\n", + " 2 0.26923 -0.004 1.000 -0.030 -0.255\n", + " 3 0.25525 -0.109 -0.030 1.000 -0.214\n", + " 4 0.33834 0.002 -0.255 -0.214 1.000\n" + ] + } + ], + "source": [ + "# fit the pdf with the Asimov dataset\n", + "fr = pdf.fitTo(data_asimov, ROOT.RooFit.Save())" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " RooFitResult: minimized FCN value: 101.271, estimated distance to minimum: 2.46569e-11\n", + " covariance matrix quality: Full, accurate covariance matrix\n", + " Status : MINIMIZE=0 HESSE=0 \n", + "\n", + " Floating Parameter FinalValue +/- Error \n", + " -------------------- --------------------------\n", + " mu_TOP 1.0000e+00 +/- 3.23e-01\n", + " mu_VBF 1.0000e+00 +/- 2.94e-01\n", + " mu_VH 1.0000e+00 +/- 5.32e-01\n", + " mu_ggF 1.0000e+00 +/- 1.10e-01\n", + "\n" + ] + } + ], + "source": [ + "# print the results\n", + "fr.Print()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "canvas = ROOT.TCanvas()\n", + "plot = ws.obj('mu_ggF').frame()\n", + "fr.plotOn(plot, 'mu_ggF', 'mu_VBF')\n", + "plot.Draw()\n", + "canvas.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.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}